RISC-V ALU与基础架构

本讲回答“一条 RISC-V 指令在硬件上究竟怎样被执行”。路线是先从补码与全加器搭出能做加减、溢出判断和移位的 ALU，再扩展到乘除法器与 IEEE 754 浮点；然后认识数据通路部件与边沿触发时序，依次搭建单周期、多周期和五级流水线处理器；最后分析流水线中的结构、数据、控制三类冒险，以及停顿、转发、提前判定等解决办法。阅读前需要掌握 L02 的 RISC-V 指令格式（R/I/S/SB）与 CPI、性能铁律，以及数字逻辑中的门电路、多路选择器和寄存器。

ALU与整数加减

RISC-V ALU 的功能与约定

处理器执行的每条算术、逻辑、比较类指令，最终都要落到同一个运算部件上完成，因此 ALU 的功能清单直接由 ISA 决定。

算术逻辑单元（Arithmetic Logic Unit，ALU）是根据操作选择信号对两个操作数做运算的组合部件。它的接口为：

• 输入：操作数 A、B，以及操作选择信号 m（operation），m 决定这一次做哪种运算；
• 输出：运算结果 result；
• 状态位：zero（结果是否为 0）、ovf（是否溢出）。

RISC-V ALU 必须支持 ISA 中的这些运算：

这些运算在 x86、MIPS 等其他 ISA 的 ALU 中基本相同；乘除法的硬件见 02 乘除法与浮点数。

指令后缀的含义

• i 后缀：第二个源操作数是指令中给出的立即数（immediate），默认按有符号数处理。例如 addi x5, x6, -4。并非每条运算都有 i 版本：没有 subi，减去一个常数用 addi 加它的相反数即可。
• u 后缀：把操作数当作无符号数（unsigned）解释，例如 sltu、divu、lbu。同样的位串按有符号和无符号解释时比较结果不同，所以需要两套指令。

扩展方式

立即数或从存储器读出的窄数据要放进 32/64 位寄存器参与运算，高位必须补齐。按指令归类有两种处理：

1. 符号扩展（sign extend）：用最高位（符号位）填充高位，保持有符号数值不变——addi、andi、slti。
2. 零扩展（zero extend）：高位一律填 0，保持无符号数值不变——lbu、lhu、lwu、ldu、sltiu、slli、srli、srai。

RISC-V 不检测溢出

传统 ISA（如 MIPS、x86）在有符号运算溢出时会给出提示或触发陷阱（trap），由系统做额外处理。RISC-V 则规定：所有算术/逻辑运算都不检测溢出（no overflow detected），溢出时结果直接按低位截断写回，硬件不做任何处理。 如果程序需要知道是否溢出，必须在代码中自己插入额外的指令来检查。 溢出的判断规则见下文“溢出检测”。

补码表示（Two’s Complement）

计算机需要用同一套加法硬件处理正数和负数，而不是另造一套减法器；补码让“减去 B”变成“加上 $-B$”，加法电路无需区分符号。

补码（two’s complement）用 $n$ 位表示有符号整数，最高位权值为 $-2^{n-1}$，其余位权值为正。$n$ 位补码的表示范围是

4 位时为 $-2^3=-8$ 到 $2^3-1=7$。

取负（negate）的规则：

1. 按位取反（complement all the bits）；
2. 再加 1。

全加器（Full Adder）

多位加法可以拆成逐位相加，每一位都要同时处理本位的两个数和低位送来的进位，这个“一位加法”单元就是全加器。

全加器（full adder, FA）有三个输入 $A$、$B$、$C_{\mathrm{in}}$ 和两个输出 $S$、$C_{\mathrm{out}}$，其中 $C_{\mathrm{in}}$、$C_{\mathrm{out}}$ 分别表示进位输入与进位输出（电路图中的 carry_in、carry_out）；半加器（half adder）则没有低位进位输入。二者的区别就在于是否接收低位进位。

真值表：

从真值表读出两个逻辑式：

• $S$ 是奇校验函数（odd parity function）：三个输入中 1 的个数为奇数时 $S=1$。
• $C_{\mathrm{out}}$ 是多数函数（majority function）：三个输入中至少两个为 1 时输出 1。

行波进位加法器与加/减法器

有了一位的全加器，接下来要解决两个问题：如何拼出 32 位加法器；如何几乎不加硬件就让它也能做减法。

32 位行波进位加法器（Ripple Carry Adder）

行波进位加法器（ripple carry adder）把 32 个一位全加器首尾串联：

1. 第 $i$ 个全加器的输入是 $A_i$、$B_i$ 和进位 $c_i$，输出本位和 $S_i$ 与进位 $c_{i+1}$；
2. 每一位的 carry_out 直接接到高一位的 carry_in；
3. 最低位的进位输入 $c_0$ 就是整个加法器的 carry_in，最高位送出的 $c_{32}$ 就是整个加法器的 carry_out。

进位像波一样从最低位逐级传到最高位，这也是它的缺点：最高位要等前面所有进位依次算完，速度慢。更快的加法器结构偏向数字电路设计，本讲不展开。

加/减法器（Adder/Subtractor）

减法 $A-B$ 等于 $A+(-B)$，而 $-B$ 的补码是“$B$ 按位取反再加 1”，所以只需在加法器上完成这两件事：

1. 按位取反：每个 $B_i$ 先与控制信号 control（0=add，1=sub）做异或后再送入全加器。异或门的一个输入为 0 时输出等于另一输入，为 1 时输出取反，所以 control=0 时送入 $B_i$，control=1 时送入 $\overline{B_i}$。
2. 加 1：把同一根 control 线接到最低位进位 $c_0$。做减法时 control=1，正好让 $c_0=1$，在最低位加上 1。

用 $u$ 表示控制信号 control（$u=0$ 做加法，$u=1$ 做减法），同一套电路满足

其中 $B\oplus u$ 表示 $B$ 的每一位都与控制位 $u$ 异或。

图：32 位行波进位加法/减法器：每位 $B_i$ 与控制信号异或，控制信号同时作为 $c_0$ 提供“+1”，进位逐级传递到 $c_{32}$；左侧示例 $0111_2-0110_2=0001_2$。

溢出检测（Overflow Detection）

RISC-V 硬件不报告溢出，软件若要检查，就需要一个简单可靠的判断依据。

溢出（overflow）指运算结果太大（或太小），无法用 32 位（例中为 4 位）有符号数表示。按操作数符号分为四种情形：

一正一负相加（或同号相减）永远不会溢出，因为结果的绝对值不会超过较大的操作数。

判断规则：设 $n$ 位加法中，进入最高位（MSB）的进位为 $c_{n-1}$，最高位送出的进位为 $c_n$，用 $O$ 表示溢出标志，则

$O=1$ 表示溢出，$O=0$ 表示没有溢出。4 位时就是比较第 4 位的进位输入与第 5 位（carry_out）的值。

为什么这条规则成立

只看最高位：设两个操作数的符号位为 $a$、$b$，结果符号位 $s = a\oplus b\oplus c_{n-1}$，$c_n = \operatorname{maj}(a,b,c_{n-1})$。

• $a=b=0$（正+正）：$c_n=0$；若 $c_{n-1}=1$，则 $s=1$ 变负，正好溢出，此时 $c_{n-1}\oplus c_n=1$。
• $a=b=1$（负+负）：$c_n=1$；若 $c_{n-1}=0$，则 $s=0$ 变正，正好溢出，此时 $c_{n-1}\oplus c_n=1$。
• $a\ne b$（异号）：$c_n = c_{n-1}$，异或恒为 0，与“异号相加不溢出”一致。

减法在加/减法器中被转换成 $A+\overline{B}+1$ 的加法，同样适用这条规则。这一证明原本留作课后练习（On your own）。

移位运算与桶形移位器

把 8 位字符打包进 32 位字、或从字中拆出某个字节，需要把所有位整体左移或右移；移位还能快速实现乘除 2 的幂。

移位（shift）把一个字中的所有位向左或向右移动若干位，移出的位丢弃，空出的位按规则填充。

逻辑移位（Logical Shift）

逻辑移位在空出的位置一律补 0：

sll  x5, x6, x7    # x5 = x6 << x7 位（移位量在寄存器中）
srl  x5, x6, x7    # x5 = x6 >> x7 位
slli x5, x8, 8     # x5 = x8 << 8 位（移位量是立即数）
srli x5, x8, 8     # x5 = x8 >> 8 位

算术右移（Arithmetic Shift）

逻辑右移会把负数的符号位变成 0，数值意义被破坏。算术移位要保持移位后数值的算术正确性：右移一位应为原值的 $\tfrac12$，左移一位应为原值的 2 倍。因此 sra 用最高位（符号位）作为移入的位。

sra  x5, x6, x7    # x5 = x6 >> x7 位，高位补符号位
srai x5, x6, 7     # x5 = x6 >> 7 位，高位补符号位

补码下不需要 sla：左移时空出的是最低位，无论逻辑还是算术都只能补 0，两者效果完全相同，所以 RISC-V 只有 sll，没有算术左移。只有右移时，移入的位取决于符号位是 0 还是 1，逻辑与算术结果才会不同。

桶形移位器（Barrel Shifter）

移位操作并不在 ALU 内部完成，而是由一个独立于 ALU 的专用电路——桶形移位器（barrel shifter）实现。用分立逻辑搭建它需要大量门，但在 VLSI 中实现起来相当容易，结构也比 ALU 简单。

乘除法与浮点数

二进制乘法与部分积（Partial Product）

逐次相加来做乘法太慢：$7\times9$ 要做 9 次加法。十进制竖式的办法是把乘数拆成各位，分别与被乘数相乘得到部分积（partial product），再错位相加。二进制也能这样做，而且更简单，因为乘数每一位只有 0 或 1。

二进制乘法：被乘数（multiplicand）与乘数（multiplier）的每一位相乘得到一个部分积，第 $j$ 个部分积左移 $j$ 位，所有部分积相加就是积；求和时的进位同样按二进制处理。$n$ 位乘 $n$ 位，积为 $2n$ 位。

部分积的每一位用与门产生：一位乘一位的真值表是 $0\cdot0=0,\ 0\cdot1=0,\ 1\cdot0=0,\ 1\cdot1=1$，和与门（AND）完全相同。所以被乘数的每一位 $A_i$ 与乘数的某一位 $B_j$ 过一个与门，就得到部分积中的 $A_iB_j$。

阵列乘法器与进位保留加法（Carry-Save Adder）

部分积有了，问题是怎么用加法器把它们快速加起来。这里用到两种加法模块（全加器的结构见 01 ALU与整数加减）：

• 半加器（HA）：输入 A、B，输出本位 S 与进位 $C_{\mathrm{out}}$；
• 全加器（FA）：输入 A、B、$C_{\mathrm{in}}$，输出 S 与 $C_{\mathrm{out}}$；
• 4 位行波进位加法器（RCA）= 1 个 HA 打头 + 串联 3 个 FA。

用 RCA 搭成的 4 位阵列乘法器

被乘数 $A_3A_2A_1A_0$，乘数 $B_3B_2B_1B_0$，积为 $S_0\ldots S_7$。

1. $A_0B_0$ 不需要和别的数相加，直接输出为 $S_0$。
2. 第 2 个部分积错开一位，与第 1 个部分积用一个 4 位 RCA 相加；$A_1B_0 + A_0B_1$ 的本位直接输出为 $S_1$；最左边的 FA 缺一个输入，接常数 0。
3. 上一步的和再与错开一位的第 3 个部分积相加（又一个 4 位加法模块），得到 $S_2$。
4. 结果再与第 4 个部分积相加，得到 $S_3,S_4,S_5,S_6,S_7$。

延迟：设每个加法器子模块耗时 $T$。RCA 中高位要等低位进位：$A_2B_0$ 与 $A_1B_1$ 求和要等 $A_1B_0+A_0B_1$ 的进位，$A_3B_0$ 与 $A_2B_1$ 又要等前一位的进位。3 行各 4 个模块共 12 个，但从第 3 个周期起，左边的加法器和下一行的加法器可以同时算，所以得到 $S_7$ 实际需要 $8T$，不是 $12T$；扩展到 6 位，延迟增加到 $14T$。 延迟的根源是进位在每一行里横向传递：三行各传 3 次，共 9 次。

进位保留：先把所有列算完，进位留给下一级

手算乘法是竖着把一列数加起来：本位写下，进位留给下一列。在硬件里，多列可以同时求和，而且进位不必马上传给左边一位，可以作为一个新的数据输入交给下一级：

1. 第一级：全加器最多 3 个输入，所以先对前三个部分积的每一列同时求和，得到本位和进位；
2. 第二级：把这些进位作为数据，和上一级的本位、第 4 个部分积一起求和；
3. 最后一级：只剩一行本位和一行进位，用一个普通加法器做一次带进位传递的加法。

这种加法模块叫进位保留加法器（carry-save adder，CSA）：模块内部不像 RCA 那样传递进位，而是把进位输入变成一个普通数据输入，相当于输入三个数、输出两个数，所以也叫 3:2 压缩器（3:2 compressor）。只有最后的总加法要等进位传递，4 位乘法只需 $6T$。

快速乘法器（备份页内容）

部分积可以并行生成、并行相加来加速乘法。 P&H 的快速乘法器把循环”展开”：不再把一个 64 位加法器用 63 次，而是用 63 个加法器，并把它们组织成能让延迟最小的结构（加法树）。

移位相加乘法器（Shift-and-Add Multiplier）

阵列乘法器每个部分积都要一行加法器，64 位时硬件开销很大。P&H 的顺序乘法器只用一个 ALU，每个周期处理乘数的一位。

第一版（被乘数 128 位、左移；乘数 64 位、右移；ALU 128 位；积 128 位；控制单元检测乘数最低位）：

flowchart TD
  S(["开始"]) --> T{"步骤 1：检测乘数第 0 位 Multiplier0"}
  T -- "=1" --> A["步骤 1a：积 + 被乘数，结果写回积寄存器"]
  T -- "=0" --> L
  A --> L["步骤 2：被乘数左移 1 位"]
  L --> R["步骤 3：乘数右移 1 位"]
  R --> C{第 64 次重复?}
  C -- "否：<64" --> T
  C -- "是" --> D(["结束"])

被乘数每次左移 1 位，正好对应”第 $j$ 个部分积左移 $j$ 位”；乘数为 1 的位才加。部分积是一个接一个地加到积里、每次加法都要完整的进位传递，所以这一版的思路属于 RCA 式，不是 CSA。

改进版：任何时刻 128 位被乘数寄存器里只有 64 位有用，积寄存器也有一半是空的，于是把它们合并：

• 被乘数寄存器和 ALU 缩为 64 位；
• 不再左移被乘数，而是把积右移；
• 去掉独立的乘数寄存器，乘数放进积寄存器的右半；
• 积寄存器加 1 位变成 129 位，用来存加法器的进位输出；
• 只剩一个移位器。

图：乘法器第一版（128 位被乘数左移、64 位乘数右移、128 位 ALU）与改进版（64 位 ALU、129 位积寄存器右移、乘数放在积寄存器右半）。

二进制除法与除法硬件

除法是试商、移位、相减的重复。 十进制要心算”让余数小于除数的最大商”（$29\div3$ 要想到 $3\times9=27$），二进制没有这个负担：每位商只能是 0 或 1，够减就是 1，不够减就是 0。所以二进制除法只需要比较和减法，不需要乘法。

比较后再减的除法电路（课堂视频）

硬件需要：存除数的寄存器、减法器、存被除数/余数的寄存器、存商的寄存器，以及一个比较大小并决定写回的控制单元（control unit）。被除数和余数放在同一个寄存器，因为够减时下一步的被减数就是这次减出来的余数。

以 8 位数为例：除数寄存器、被除数/余数寄存器各 16 位，商寄存器 8 位。

1. 初始化：29 放在余数寄存器的低 8 位；3 放在除数寄存器的高 8 位；商全 0。
2. 比较：余数寄存器与除数寄存器比较。
3. 够减：商从右端移入 1（最左位被挤出，商寄存器整体左移），余数寄存器改写为差。
4. 不够减：商移入 0，余数寄存器不变。
5. 除数右移 1 位，模拟”往下看一位”，回到第 2 步。

用 $3\cdot2^k$ 表示除数当前的位置：$k\ge4$ 时 $3\cdot2^k\ge48>29$，商位都是 0；$k=3$ 时 $24\le29$，商位 1，余数改为 $5=101_2$；$k=2,1$ 时 $12,6>5$，商位 0；$k=0$ 时 $3\le5$，商位 1，余数改为 $10_2$。除数从高 8 位移到低 8 位共右移 8 次，得到商 00001001、余数 10。 这一版每次先比较，只有够减才写回差。

P&H 第一版：恢复余数除法（Restoring Division）

P&H 第一版除法硬件：除数寄存器 128 位、右移；ALU 128 位；余数寄存器 128 位；商寄存器 64 位、左移。它不先比较，而是先减、看符号、不够减再加回来：

1. 余数寄存器 ← 余数 − 除数；
2. 检测余数：
   • 2a（余数 ≥ 0）：商左移，新的最低位置 1；
   • 2b（余数 < 0）：把除数加回余数寄存器，恢复原值；商左移，新的最低位置 0；
3. 除数右移 1 位；
4. 未到第 65 次重复就回到第 1 步，第 65 次后结束。

图：除法器第一版硬件（128 位除数右移、128 位余数、64 位商左移）与恢复余数除法流程：先减，结果为负则恢复并商 0，重复 65 次。

P&H 第 391 页另有改进版除法硬件。

RISC-V 乘除指令与溢出处理

两个 64 位数相乘得到 128 位积，整数除法同时产生商和余数，但 RISC-V 的 R 型格式（funct7 rs2 rs1 funct3 rd opcode）只有一个目的寄存器 rd，所以每种结果各用一条指令：

mul  x5, x7, x8   # x5 = x7 * x8 的低 64 位
mulh x6, x7, x8   # x6 = x7 * x8 的高 64 位
div  x5, x7, x8   # x5 = x7 / x8（商）
rem  x6, x7, x8   # x6 = x7 % x8（余数）

128 位积两半都要时就执行两条指令，这是只有一个目的寄存器带来的代价。

性能：乘法本质上是多次加法加移位，即使用快速专用硬件，也比加法器复杂、慢得多；除法器更复杂、更慢。 设计处理器时要考虑这一点。

溢出与除零：RISC-V 的除法和乘法一样忽略溢出，商是否过大要由软件判断；除数为 0 时也没有硬件机制通知，软件（或编译器生成的代码）必须先显式检查除数。

IEEE 754 浮点表示（Floating Point）

地球年龄约 $4\,600\,000\,000 = 4.6\times10^9$ 年，1 个原子质量单位约 $1.6\times10^{-27}$ kg，两者都无法用 32 位整数编码。浮点数借用科学计数法，把数写成 $(-1)^{s}\times F\times2^E$；基数 2 固化在浮点运算单元（FPALU）的设计里，不需要存储。

单精度仍要放进 32 位：

总位数固定时，多给 $F$ 就提高精度（数有多准），多给 $E$ 就扩大范围（数能有多大或多小），两者此消彼长。

IEEE 754 编码规则

绝大多数计算机遵循 IEEE 754 标准，规格化数的值为

• 隐藏位（hidden bit）：有效数字规格化为 $1.xxx$ 的形式，最高位一定是 1，所以不存储；$F$ 只存小数点后的部分。
• 偏置表示（excess/biased notation）：$E$ 按无符号数存储，以 $B$ 表示指数偏置，实际指数为 $E-B$，这样不需要符号位也能表示负指数。单精度 $B=127$，双精度 $B=1023$。
• $E$ 放在 $F$ 前面：这是为了方便浮点数排序，同号时位串的大小顺序与数值顺序一致，可以按整数比较。

特殊编码由 $E$ 的全 0、全 1 两端给出：

浮点加法步骤（备份页内容）

计算 $(F_1\times2^{E_1}) + (F_2\times2^{E_2}) = F_3\times2^{E_3}$：

1. 恢复 $F_1$、$F_2$ 的隐藏位。
2. 对阶：设 $E_1\ge E_2$，把 $F_2$ 右移 $E_1-E_2$ 位，移出的位用舍入位（round）、保护位（guard）和粘滞位（sticky）三位记录。
3. 把对阶后的 $F_2$ 加到 $F_1$，得到 $F_3$。
4. 规格化 $F_3$，使其为 $1.XXXX\ldots$ 的形式：
   • $F_1$、$F_2$ 同号时 $F_3\in[1,4)$，最多右移 1 位，同时 $E_3$ 加 1；
   • 异号时 $F_3$ 可能需要左移很多位，每左移一位 $E_3$ 减 1。
5. 舍入 $F_3$，舍入后可能需要再规格化一次。
6. 存储前把 $F_3$ 的最高位重新隐藏。

如何进一步提高精度，见 P&H 第 427–429 页。

RISC-V 浮点指令

RISC-V 有独立的浮点寄存器堆 f0–f31，与整数寄存器 x0–x31 分开，并用专门的指令在它们和内存之间传数据。

flw   f1, 54(x5)     # f1 = Memory[x5+54]（读 32 位字）
fsw   f1, 58(x5)     # Memory[x5+58] = f1
fadd.s f2, f4, f6    # 单精度加法 f2 = f4 + f6
fadd.d f2, f4, f6    # 双精度加法
flt.s x5, f2, f4     # if (f2 < f4) x5 = 1; else x5 = 0
flt.d x5, f2, f4     # 双精度比较，语义相同

同理还有 fsub.s、fsub.d、fmul.s、fmul.d、fdiv.s、fdiv.d；比较中的 lt 也可以换成 eq、le（feq.s、fle.s、feq.d、fle.d）。

命名规律：在整数指令前加 f，后缀 .s 表示单精度、.d 表示双精度。比较指令读两个浮点寄存器，结果写入整数寄存器 x5。

数据通路部件与时钟

处理器组织与寄存器传输级（RTL）

处理器分为数据通路（Datapath）和控制（Control）两部分，完整的组织结构见 L02《04 ISA抽象与RISC思想》，这里只回顾本讲要用到的分工：

• 数据通路：由部件（components，执行指令所需的运算单元和存储单元，如寄存器堆）和互连（interconnects，把部件连起来，使指令能够完成，并能从存储器取数、向存储器存数）组成。互连既包括处理器内部的连接，也包括处理器与外部存储器之间的连接。
• 控制：① 从存储器取入指令（Fetch）；② 译码后发出信号，控制数据在各部件之间的流动以及各部件执行什么操作；③ 管理指令执行的先后顺序。

本讲要实现的 RISC-V 指令分三类：访存（ld/sd）、算术/逻辑（add 等）和控制流（beq）。

要设计硬件，先得精确写出每条指令“做什么”。寄存器传输级（Register Transfer Level, RTL）就是描述寄存器之间数据流动的语言，它给每条指令赋予确切含义。所有指令都从地址 PC 处取出，取指后顺序执行时 $PC \leftarrow PC + 4$（每条指令 32 位 = 4 字节）。

用 RISC-V 的字段名（rs1、rs2、rd，12 位立即数 imm）写出四类典型指令：

其中 sext 表示符号扩展，访存地址 = 基址寄存器 + 符号扩展后的偏移量。

RTL 之外还有更底层的门级（gate-level）视角：直接展示每个时钟周期里各个逻辑门怎样翻转、互相传递信号，从而实现处理功能，ARM1 处理器的门级仿真就是这样的例子。 本讲从 RTL 这一层出发，把处理器拆成部件，再一步步组装成逻辑层面的处理器。

组合元件与存储元件

数据通路里的硬件按“是否保存状态”分成两类。

组合元件（combinational element）只对数据做运算：输出完全由当前输入决定，不记忆任何东西。

• 扩展器（Extend）：把指令中的立即数扩展成 64 位数据（部件图沿用 MIPS 标注 16→64，RISC-V 实际是 12 位立即数扩展到 64 位）。扩展方式见 01 ALU与整数加减。
• ALU：对两个 64 位输入做运算，输出 ALU result，同时给出状态输出 zero（结果是否为 0）和 overflow（是否溢出）。ALU 支持的运算见 01 ALU与整数加减。
• 多路选择器（multiplexor, Mux）：一种简单的多功能逻辑单元，根据选择信号让输入 0 或输入 1 之一通过。当同一个部件的输入可能来自不同来源时，就用 Mux 选择。

存储元件（storage / state element）保存数据，即处理器的状态：

寄存器地址是 5 位，因为 $2^5 = 32$ 正好寻址 32 个寄存器；指令长 32 位，数据通路宽 64 位（RV64）。

数据通路的控制信号

部件本身只提供“能做什么”，还需要控制信号决定“这一条指令让它做什么”，即选择操作、控制数据流向。 部件图上的控制信号如下：

此外 ALU 的 zero、overflow 是反向输出给控制逻辑的状态信号（例如 beq 用 zero 判断两数是否相等）。这些信号由控制单元根据指令的 opcode、funct 等字段产生，具体取值和控制表见 04 单周期数据通路。

CPU 时钟与边沿触发

各部件必须在硬件层面同步：何时读取、何时写入，需要一个统一的时间基准，这就是时钟（clock, Clk）。时钟接到 PC、寄存器堆和数据存储器这些需要同步写入的存储元件上。 在本讲的模型里，指令存储器不接时钟：给它地址就直接输出指令，行为像组合逻辑。

时钟从哪里来

CPU 时钟是处理器内部的计时器件，用石英晶体给处理器提供持续、稳定的脉冲流。 产生过程：

1. 石英晶振（quartz crystal）通电后振荡，输出频率固定的正弦波。
2. 整形：数字电路按方波工作，所以要把正弦波整形（模拟到数字转换）成方波。
3. 倍频：晶振本身频率较低（课上给出的量级是一百多 kHz 到 1 MHz），而现代 CPU 约 3 GHz，因此在晶振之后接锁相环（Phase-Locked Loop, PLL），按需要把频率调高。 时钟频率与功耗的长期趋势见 L01《05 技术趋势与功耗墙》。

边沿触发计时方法（Edge-Triggered Clocking）

计时方法（clocking methodology）规定信号何时可以被读、何时被写。 时钟信号从低电平跳到高电平的时刻叫上升沿，从高跳到低叫下降沿，统称边沿（edge）。边沿触发是指存储元件只在时钟边沿更新内容，大多数电路采用这种方法。

一个时钟周期内的典型执行过程：

1. 读：时钟沿到来后，状态元件 1 输出其内容。
2. 算：这些值流经组合逻辑，被处理。
3. 写：在下一个时钟沿，把结果写入一个或多个状态元件（状态元件 2）。

flowchart LR
  S1[状态元件1 State Element 1] -->|读出内容| C[组合逻辑 Combinational logic]
  C -->|在下一个时钟沿写入| S2[状态元件2 State Element 2]
  CLK[时钟 clock] --> S1
  CLK --> S2

几乎所有同步电路都满足这个结构：每个周期都从存储元件出发，经组合逻辑，回到存储元件。这样每个周期的计算结果都能被保存下来，下一个周期可以接着做新的计算。所谓“单周期”，就是一条指令的读—算—写全部在一个时钟周期内完成。

单周期时序约束

既然一个周期内要把数据从一个寄存器读出、穿过组合逻辑、再写进另一个寄存器，周期就必须足够长，能容纳这条路径上最慢的情况。 涉及四个时间参数：

• $T_{\rm clk\_q}$：时钟沿到达后，寄存器输出端出现新值的延迟（clock-to-output）。
• $T_{\rm max\_comb}$：信号穿过组合逻辑的最长延迟（关键路径）。
• $T_s$：建立时间（setup time），时钟沿到来之前，寄存器输入必须保持稳定的时间。
• $T_h$：保持时间（hold time），时钟沿到来之后，寄存器输入还必须继续保持稳定的时间。

图：边沿触发下一个周期必须覆盖寄存器输出延迟、最长组合逻辑延迟与建立时间：$T_{\mathrm{cycle}}\ge T_{\mathrm{clk\_q}}+T_{\mathrm{max\_comb}}+T_s$。

时序图上，从第一个上升沿开始依次是 $T_{\rm clk\_q}$、$T_{\rm max\_comb}$、$T_s$，它们必须在下一个上升沿之前全部结束；$T_h$ 跨在下一个上升沿之后。因此时钟周期 $T_{\rm cycle}$（源材料记为 $T_t$）必须满足：

保持时间通常自然满足，因为 $T_{\rm clk\_q} > T_h$：时钟沿过后，上游寄存器至少要经过 $T_{\rm clk\_q}$ 才输出新值，这时下游寄存器的保持窗口 $T_h$ 已经过去，旧输入不会被提前改掉。所以设计时钟周期时一般只考虑上式。

写控制信号

上面的计时方法默认状态元件每个时钟周期都写入。如果某个状态元件不是每周期都写，就必须给它一个显式的写控制信号（write control signal，写使能）。 规则是 只有写控制信号有效、并且时钟沿到来时，才发生写入；二者缺一不可。

按这个规则检查各存储元件：

单周期数据通路

单周期设计的思路

要让处理器真正执行指令，需要把上一节的组合元件、状态元件和控制信号（见 03 数据通路部件与时钟）连成一条完整的数据通路。最简单的连法是让每条指令在一个时钟周期内走完全部步骤。

单周期数据通路（single-cycle datapath）是指每条指令的取指（Fetch）、译码（Decode）、执行（Execute）都在同一个时钟周期内完成的设计。 本节实现的是一个简化的 RISC-V 子集：

• 访存指令：ld、sd
• 算术逻辑指令：add、sub、and、or
• 控制流指令：beq

通用的执行流程是：用 PC 提供指令地址，从存储器取指并更新 PC；译码并读寄存器；执行。所有指令在读完寄存器后都会用到 ALU，只是用途不同：算术指令用它做运算，访存指令用它算地址，分支指令用它做比较。

三个阶段对应的部件如下：

flowchart LR
  subgraph F[取指 Fetch]
    PC[PC] --> IM[指令存储器 Instruction Memory]
  end
  subgraph D[译码 Decode]
    DEC[控制单元 Control Unit] 
    RF[寄存器堆 Registers]
  end
  subgraph E[执行 Execute]
    ALU[ALU] --> DM[数据存储器 Data Memory]
  end
  IM --> DEC
  IM --> RF
  RF --> ALU

取指与译码

取指（Fetch）

取指要做两件事：

1. 读指令：把 PC 作为地址送入指令存储器（Instruction Memory），读出 32 位指令 Instr[31-0]。
2. 更新 PC：用一个专用加法器计算 PC+4，作为顺序执行时下一条指令的地址。

这两个部件都不需要显式控制信号：

• PC 每个周期都被更新，所以不需要写控制信号；
• 指令存储器每个周期都被读，所以不需要读控制信号。

译码（Decode）

译码同样分两部分：

1. 把指令中的 opcode 和 funct 字段送入控制单元（Control Unit），由它产生后续各部件的控制信号。
2. 从寄存器堆（Register File）读出两个源操作数；寄存器地址直接取自指令字段。

RISC-V 的编码让字段位置在各格式间尽量固定，这使控制单元和寄存器堆可以直接从固定位上取值，不必先判断指令类型：

• opcode 总在 bits 6-0；
• 要读的寄存器总由 rs1（bits 19-15）和 rs2（bits 24-20）给出；
• 要写的寄存器总在 rd（bits 11-7）；
• 另一个操作数也可能是 12 位偏移量，用于分支或 load/store。

S 和 SB 格式没有 rd，于是把立即数拆开放在 rd 原来的位置（bits 11-7），这样 rs1、rs2 的位置保持不变。

三类指令的数据通路

在取指和译码之后，不同指令在执行阶段需要的部件不同。下面逐类搭建。

R 型指令

R 型指令（add、sub、and、or）对 rs1、rs2 中的值执行由 op 和 funct 决定的运算，结果写回寄存器堆的 rd。

1. 寄存器堆的 Read Data 1、Read Data 2 送入 ALU 两个输入端。
2. ALU 控制（ALU control）决定做哪种运算；ALU 还输出 zero 和 overflow 标志。
3. ALU 结果送回寄存器堆的 Write Data，写地址为 rd。

寄存器堆并非每个周期都被写（例如 sd 就不写），因此需要显式写控制信号 RegWrite。

Load 与 Store

访存指令的三个动作：

1. 算地址：基址寄存器（译码时从寄存器堆读出）+ 指令中符号扩展的 12 位偏移。
2. store：把译码时读出的另一个寄存器值（rs2）写入数据存储器（Data Memory）。
3. load：从数据存储器读出数据，写回寄存器堆（rd）。

为此新增两个部件：

• 立即数生成器（Imm Gen）：从 32 位指令中取出立即数字段，符号扩展成 64 位（图中标为 32 → 64，signed）。
• 数据存储器：输入 Address、Write Data，输出 Read Data；由 MemRead、MemWrite 两个信号控制读写。

例如 ld x5, 40(x6)，若 x6 = 0x2000，则 ALU 计算 0x2000 + 40 = 0x2028，从该地址读出 8 字节写入 x5。

分支 beq

分支指令要完成两件事：

1. 判等：把译码时读出的两个寄存器值送入 ALU 相减，用 ALU 的 zero 输出判断是否相等——相等时 zero = 1。
2. 算目标地址：Imm Gen 把 12 位偏移符号扩展到 64 位，经 Shift left 1 左移一位，再由一个独立的加法器与 PC 相加：

左移 1 位是因为 SB 格式不存储 imm[0]（偏移总是 2 的倍数），存储的 12 位实际是 imm[12:1]。

最后由分支控制逻辑在两个候选中选新 PC：

PCSrc = 0 选 PC+4，PCSrc = 1 选分支目标。

组装完整数据通路与多路选择器

把上述片段合成一条数据通路时，要加入控制线和多路选择器。 单周期设计带来三条约束：

1. 每个资源每条指令只能用一次，因此必须复制一些部件：指令存储器与数据存储器分开；用三个加法器（ALU、PC+4 加法器、分支目标加法器）而不是共用一个。
2. 共享部件的输入端需要多路选择器（multiplexor），由控制线选择数据来源。
3. 写信号控制是否写寄存器堆和数据存储器。

时钟周期由最长路径决定。

R 型与访存指令共用 ALU 和寄存器堆写端口，但数据来源不同，于是加入两个选择器； 再加上分支的 PC 选择器，共三个：

完整的单周期数据通路如下：控制单元读入 Instr[6-0]，输出 Branch、MemRead、MemtoReg、MemWrite、ALUSrc、RegWrite 和 2 位 ALUOp；ALU 控制单元根据 ALUOp 和 Instr[30,14-12]（funct7 的第 30 位与 funct3）产生具体的 ALU 操作；Branch 与 zero 经与门得到 PCSrc。

图：带控制单元的单周期数据通路：控制单元由 Instr[6-0] 产生 RegWrite、ALUSrc、MemRead/MemWrite、MemtoReg、Branch，Branch 与 zero 相与得到 PCSrc。

控制单元与控制表

控制信号负责两件事：选择要执行的操作（ALU 运算、寄存器堆与存储器的读写），以及控制数据流向（多路选择器的输入）。 控制单元只看 opcode 就能确定这些信号，下表给出四类指令的取值：

图：R-format、ld、sd、beq 四类指令的单周期控制信号取值表。

X 表示“无关”（don’t care）：sd 和 beq 不写寄存器堆（RegWrite = 0），所以 MemtoReg 选哪一路都不影响结果。

每一行都可以从数据流推出来：

1. R 型： PC 选 PC+4；结果要写回 rd，RegWrite = 1；第二操作数来自寄存器，ALUSrc = 0；不访问数据存储器，MemRead = MemWrite = 0；写回数据取 ALU 结果，MemtoReg = 0；ALU 运算由 funct 字段决定，ALUOp = 10。
2. ld： PC 选 PC+4；ALU 一端是基址寄存器、另一端是扩展到 64 位的立即数，ALUSrc = 1；读数据存储器，MemRead = 1；读出的数据经 MemtoReg = 1 写回寄存器堆，RegWrite = 1；ALU 做加法，ALUOp = 00。
3. sd：ALU 同样算“基址 + 立即数”，ALUSrc = 1，ALUOp = 00；MemWrite = 1 把 rs2 写入存储器；不写寄存器，RegWrite = 0，MemtoReg = X。
4. beq： 两个寄存器值比较，ALUSrc = 0；ALU 做减法，ALUOp = 01；Branch = 1，与 zero 相与决定 PCSrc；不访存、不写寄存器。

一条 ld 指令的完整路径经过了所有主要部件，它就是单周期设计中最长的路径：

flowchart LR
  IM[指令存储器] --> RF[读寄存器堆]
  RF --> ALU[ALU 算地址]
  ALU --> DM[数据存储器读]
  DM --> MUX[MemtoReg 选择器]
  MUX --> WB[写回寄存器堆]

单周期设计的优缺点

优点：

• $\mathrm{CPI}=1$：每条指令恰好一个周期，并且永远是 1。
• 简单、易于理解。

$\mathrm{CPI}=1$ 并不是性能上限：后续课程讲到的架构（如每周期完成多条指令的超标量处理器）CPI 一般都小于 1。单周期的特点只是 CPI 恒定，代价全部落在时钟周期上。

缺点：

1. 时钟周期利用率低。 时钟周期必须按最慢的指令来定。ld 要依次经过取指、读寄存器堆、ALU、数据存储器、写回，是最长的路径；sd 不需要写回，比 ld 短，但也只能占用同样长的周期，剩余时间被浪费：时序图上 Load 占满一个周期，Store 之后跟着一段 Waste。对浮点乘法这类更复杂的指令，这个问题更严重：只要指令集中有一条慢指令，所有指令都要跟着变慢。
2. 浪费面积。 由于一个周期内部件不能共享，一些功能单元必须复制：除了 ALU 外还要有专门更新 PC 的加法器；指令存储器和数据存储器也必须分开，而在更好的设计中二者本可以合并。

时钟周期下限的具体约束式（$T_{\rm clk\_q}$、$T_{\rm max\_comb}$、$T_s$）见 03 数据通路部件与时钟。为解决这两个问题，下一节把一条指令拆成多个较短的周期并复用部件，见 05 多周期数据通路。

多周期数据通路

多周期的动机：单周期浪费了什么

单周期处理器（见 04 单周期数据通路）在一个周期内完成取指、译码、执行，所以大多数指令 $\mathrm{CPI}=1$；但这个周期必须足够长，能完成最耗时的那条指令。

最长的是 load，所有指令都得陪它用这个长周期，store 等短指令提前做完后只能空等，剩下的时间就是浪费（waste）；具体分析见 04 单周期数据通路 的“单周期设计的优缺点”。

多周期数据通路（multicycle datapath）的办法是：把每条指令拆成若干个更短的步骤，每步占一个时钟周期，于是不同指令可以花不同数量的周期完成，短指令不再陪着长指令等待。

三条设计原则

从单周期改成多周期，要回答三个问题：

1. Q1 怎样让一条指令用多于 1 个周期完成？ 把指令拆成小步骤，每步一个周期，依次执行。
2. Q2 怎样更高效地使用数据通路部件、去掉不必要的重复资源？ 允许同一个功能部件在一条指令内被使用多次，只要这几次落在不同的周期。
3. Q3 单周期的控制信号可以只由 opcode 决定，多周期怎么办？ 用有限状态机（finite state machine, FSM）做控制：控制信号既取决于 opcode，也取决于当前处在第几步。

拆分步骤时还有两条约束：

• 平衡每一步的工作量（时钟周期由最慢的一步决定，步骤越不均衡浪费越多）；
• 限制每个周期只启用一个主要功能部件（存储器、寄存器堆或 ALU 之一），这样部件才能跨周期复用。

五个执行步骤与各类指令的周期数

五步（five steps）分别是：

1. IFetch：取指令，并更新 PC（PC+4）。
2. Dec：指令译码、读寄存器、对偏移量/立即数做符号扩展。
3. Exec：执行 R 型运算；或计算访存地址；或做分支比较。分支和跳转在这一步完成。
4. Mem：load 读存储器；store 写存储器并完成；R 型把结果写回寄存器堆并完成。
5. WB：load 把从存储器读出的数据写回寄存器堆，load 在这一步完成。

各类指令在第几步结束，就决定了它的周期数：

所以在这种多周期设计中，指令需要 3–5 个周期：load 最长，分支和跳转最短。

timeline
  title 多周期时序：load 后接 store（共 9 个周期）
  周期 1 : load IFetch
  周期 2 : load Dec
  周期 3 : load Exec
  周期 4 : load Mem
  周期 5 : load WB
  周期 6 : store IFetch
  周期 7 : store Dec
  周期 8 : store Exec
  周期 9 : store Mem

单周期执行同样两条指令要 2 个长周期；多周期则是 5 + 4 = 9 个短周期，下一条指令紧接在上一条指令真正结束之后开始，没有“空等”。

内部寄存器与部件复用

一条指令被拆成多个周期后，后一步要用前一步的结果；而组合逻辑在周期末不会“记住”任何东西。因此，按时钟方法学（读状态元件 → 经过组合逻辑 → 写状态元件），在每个周期末，把下一周期要用的值存进一个内部寄存器。

内部寄存器（internal registers）是程序员不可见的寄存器，共五个：

• IR（Instruction Register，指令寄存器）：保存从存储器读出的指令；
• MDR（Memory Data Register，存储器数据寄存器）：保存从存储器读出的数据；
• A、B：保存寄存器堆两个读端口读出的数据；
• ALUOut（ALU 输出寄存器）：保存 ALU 的运算结果。

除 IR 外，这些寄存器只在相邻两个周期之间保存数据，每个周期都可以被覆盖，所以不需要写控制信号；IR 要在整条指令的执行过程中保持指令内容，因此带有写使能 IRWrite。需要留给后续指令使用的数据，则存放在程序员可见的状态中：寄存器堆、PC 或存储器。

有了内部寄存器，功能部件就能在不同周期复用：

• 只需一个存储器：取指和访存发生在不同周期，同一个存储器既存指令又存数据，但每个周期只能访问一次；
• 只需一个 ALU：单周期里专门做 PC+4 的加法器被去掉，PC 更新改由 ALU 在 IFetch 周期完成，但每个周期只能做一次 ALU 运算。

以 load 为例，数据在各周期之间的流动是：PC → 存储器（读指令）→ IR → 寄存器堆读 → A（及立即数）→ ALU → ALUOut（地址）→ 存储器（读数据）→ MDR → 寄存器堆写。每一个箭头跨过的周期边界上，都有一个内部寄存器把值接住。

flowchart LR
  PC[PC] --> M1[存储器 读指令]
  M1 --> IR[IR]
  IR --> RF[寄存器堆 读]
  RF --> A[A / B]
  A --> ALU[ALU 计算地址]
  ALU --> AO[ALUOut]
  AO --> M2[存储器 读数据]
  M2 --> MDR[MDR]
  MDR --> WB[寄存器堆 写回]

带控制信号的多周期数据通路

把内部寄存器、多路选择器和控制信号加到一起，就得到完整的多周期数据通路（RISC-V 版本，立即数生成 Imm Gen 输出 64 位，分支偏移左移 1 位）：

图：RISC-V 多周期数据通路：单一存储器与 ALU，内部寄存器 IR、MDR、A、B、ALUOut，以及 PCWrite、IorD、IRWrite、ALUSrcA/B、PCSource 等控制信号。

图中主要的多路选择器和控制信号：

• IorD：存储器地址来自 PC（0，取指）还是 ALUOut（1，访存）——单一存储器的代价；
• MemRead / MemWrite：存储器读、写使能；IRWrite：把读出的内容写入 IR；
• MemtoReg：写回寄存器堆的数据来自 MDR（1，load）还是 ALUOut（0，R 型）；RegWrite：寄存器堆写使能；
• ALUSrcA：ALU 第一个操作数为 PC（0）或 A（1）；
• ALUSrcB：ALU 第二个操作数为 B（0）、常数 4（1）、立即数（2）或左移 1 位的立即数（3）；
• ALUOp：送给 ALU control，与指令的 Instr[30,14-12]（funct7 的第 30 位和 funct3）共同决定 ALU 操作；
• PCSource：新 PC 取 ALU 的直接输出（0，IFetch 的 PC+4）还是 ALUOut（1，分支目标）；
• PCWrite / PCWriteCond：PC 无条件写，或在 zero 为 1 时条件写（与门 + 或门合成 PC 的写使能）。

与单周期的数据通路图一样，这张图重在看懂各部件和信号的逻辑，而不是默画。

有限状态机控制

单周期中，opcode 足以决定所有控制信号。多周期中，opcode 只告诉你 ALU 该做什么运算，却不能告诉你下一个周期该做哪一步——同一条 load 在第 1 周期要读指令、第 4 周期要读数据，控制信号完全不同。

有限状态机控制（FSM control）由三部分组成：

1. 状态集合：当前状态保存在状态寄存器（State Register）中，每个状态对应一步；
2. 次态函数（next state function）：由当前状态和输入（opcode）决定下一个状态；
3. 输出函数（output function）：由当前状态和输入决定这一周期要驱动的数据通路控制信号。

示例 FSM

下面是一个示例 FSM（状态从 0 编号）：

图：多周期控制有限状态机：状态 0 取指、1 译码，按操作码分支到访存地址计算（2→3/5→4）、R 型（6→7）、分支（8）与跳转（9），每个状态标出控制信号。

stateDiagram-v2
  [*] --> S0
  S0: 0 取指 IFetch
  S1: 1 译码/读寄存器 Dec
  S2: 2 访存地址计算
  S3: 3 访存（读）
  S5: 5 访存（写）
  S4: 4 写回 WB
  S6: 6 执行 R 型
  S7: 7 R 型完成
  S8: 8 分支完成
  S9: 9 跳转完成
  S0 --> S1
  S1 --> S2: Op = LW 或 SW
  S1 --> S6: Op = R-type
  S1 --> S8: Op = BEQ
  S1 --> S9: Op = J
  S2 --> S3: Op = LW
  S2 --> S5: Op = SW
  S3 --> S4
  S4 --> S0
  S5 --> S0
  S6 --> S7
  S7 --> S0
  S8 --> S0
  S9 --> S0

各状态的输出（未列出的写使能为 0）：

逐状态读出机制：

1. 状态 0：以 PC 为地址（IorD=0）读存储器，结果写入 IR（IRWrite）；同时 ALU 计算 PC+4（ALUSrcA=0 选 PC，ALUSrcB=01 选常数 4，ALUOp=00 做加法），直接写回 PC（PCWrite，PCSource=00）。存储器和 ALU 在同一周期做不同的事，不冲突。
2. 状态 1：读寄存器到 A、B；ALU 空闲，顺便用它预先算出分支目标（ALUSrcA=0 选 PC，ALUSrcB=11 选移位后的立即数），存入 ALUOut。此时还不知道是不是分支，算了也无妨。
3. 状态 2（load/store）：ALU 计算 A + 立即数（ALUSrcA=1，ALUSrcB=10）得到访存地址存入 ALUOut。随后按 opcode 分叉：load 去状态 3，store 去状态 5。
4. 状态 3 → 4（load）：以 ALUOut 为地址（IorD=1）读存储器到 MDR；下一周期把 MDR 写回寄存器堆（MemtoReg=1，RegWrite）。共 0→1→2→3→4，5 个周期。
5. 状态 5（store）：以 ALUOut 为地址写存储器（MemWrite），共 4 个周期。
6. 状态 6 → 7（R 型）：ALU 对 A、B 运算（ALUSrcB=00，ALUOp=10 表示按 funct 决定运算），结果写回寄存器堆（MemtoReg=0），共 4 个周期。
7. 状态 8（分支）：ALU 做 A−B 比较（ALUOp=01），若 zero=1 则 PCWriteCond 生效，PC 取 ALUOut 中在状态 1 算好的目标（PCSource=01），共 3 个周期。
8. 状态 9（跳转）：把跳转目标写入 PC（PCSource=10），共 3 个周期。

每条指令完成后都回到状态 0，开始取下一条指令。

多周期的优缺点

优点：

• 时钟周期利用更高效：每个周期只需容纳一个“步骤”，而不是整条最长指令，不同指令完成时间可以不同；
• 功能部件可以在一条指令内跨周期多次使用，从而节省部件数量（单一存储器，ALU 取代 PC 加法器）。

缺点：

• 需要额外的内部状态寄存器；
• 需要更多多路选择器（IorD、ALUSrcA、四选一的 ALUSrcB、PCSource 等）；
• 控制更复杂，要用 FSM 实现。

多周期和单周期一样，同一时刻只执行一条指令；让多条指令的步骤重叠执行，就是下一节的流水线，见 06 流水线设计与性能。

流水线设计与性能

吞吐量与延迟：为什么还要流水线

多周期处理器把一条指令拆成若干短周期，但同一时刻仍只有一条指令在数据通路里，大部分部件处于空闲，整体仍然慢。 流水线不再追求让单条指令更快，而是从吞吐量角度提升性能。

• 吞吐量（throughput）：单位时间内完成的工作量（例如每周期完成的指令数 IPC）。
• 延迟（latency）：一条指令从开始到完成所经历的时间，也称执行时间、响应时间。

（备份页内容）回顾性能方程 $T_{\mathrm{CPU}} = \mathrm{CPI}\times\mathrm{CC}\times\mathrm{IC}$（CC 为时钟周期，IC 为指令数，见 L02《02 CPI与性能铁律》），想让程序更快有三条路：

1. 把指令周期拆得越来越细：拆到一定程度后收益递减，加载状态寄存器花的时间与真正做事的时间相当。
2. 当前指令尚未完成就开始取下一条并执行：这就是流水线，现代处理器几乎都采用。
3. 一次取多条指令并执行：超标量（superscalar），后续课程讨论。

运油类比：要把大量石油运走，有三种方案——

食堂打饭也是同理：多周期好比一个学生依次拿完米饭、汤、泡菜、鸡蛋，下一个人才开始；流水线则是第一个人去拿汤时，第二个人已经在拿米饭，各窗口同时有人。

（备份页内容）对比三种实现执行 lw、sw、R 型指令的时间轴：单周期每条指令占一个很长的周期，短指令也要等满整个周期（浪费）；多周期按指令所需步数占若干短周期；流水线中每条指令仍走 5 个阶段，但相邻指令错开一个周期重叠执行。 流水线前三个周期的重叠情况如下：

flowchart LR
  subgraph C1[周期1]
    A1["lw: IF"]
  end
  subgraph C2[周期2]
    A2["lw: ID"]
    B2["sw: IF"]
  end
  subgraph C3[周期3]
    A3["lw: EX"]
    B3["sw: ID"]
    R3["R型: IF"]
  end
  C1 --> C2 --> C3

流水线的两个固有代价：时钟周期（即每一级的时间）受最慢的一级限制；对某些指令来说部分阶段是空转的（例如 R 型指令的 MEM 级什么也不做）。

流水线数据通路的三条设计原则

从多周期改成流水线时，核心变化是”多条指令同时在数据通路的不同阶段”，这带来三个问题，对应三条设计原则：

1. Q1 部件冲突：五个阶段 IF、ID、EX、MEM、WB 在同一周期都要工作，多周期中被复用的部件此时会被同时争用。→ 像单周期那样重新复制部件。
2. Q2 状态保存：PC 每个周期都在更新，后续阶段却还需要”自己那条指令”的 PC 和指令字。→ 增加流水线寄存器记录每条指令的 PC、指令和中间数据。
3. Q3 控制信号：不同阶段正在执行的是不同指令，所需控制信号各不相同。→ 让控制信号随数据一起经流水线寄存器向后传递。

原则一：复制数据通路部件

复制后的部件组合与原来的单周期数据通路相同：

• 指令存储器与数据存储器分离（IM/DM）：IF 取指与 MEM 访存可在同一周期进行。
• 两个加法器 + 一个 ALU：一个加法器算 PC+4，一个算分支目标 PC+偏移，ALU 专用于 EX 级运算，不再像多周期那样由 ALU 兼算 PC。

例外是寄存器堆：只需一个就能同时服务 ID（读）和 WB（写）。

• 读与写使用寄存器堆上不同的端口；
• 写操作发生在周期的前半段，读操作发生在后半段。这样同一周期内 WB 先写入的值，ID 在后半周期就能读到。

原则二：流水线寄存器（Pipeline Register）

流水线寄存器是插在相邻两级之间的状态寄存器，用来把各级隔离开：后面阶段需要用到的任何数据，都必须经流水线寄存器逐级传递下去。 为简化作图，每两级之间的一组寄存器被看作一个”大”流水线寄存器，按其两侧阶段命名为 IF/ID、ID/EX、EX/MEM、MEM/WB。

各级寄存器中保存的内容（上标表示该值供哪一级使用）：

其中 $R$ 表示沿流水线传递的 ALU 结果，对应图中的 Out；上标表示所在阶段。

图：四个流水线寄存器 IF/ID、ID/EX、EX/MEM、MEM/WB 把 PC、指令、寄存器读出值与 ALU 结果逐级传递。

可以看到 PC 和指令字一路从 IF/ID 传到 MEM/WB：许多信息在当前阶段用不上，但为了最后一级能用到，必须在各级之间不停地传。

目的寄存器号必须一路传到 WB：目的寄存器由 IF 取出的指令中的 rd 字段决定，但寄存器堆的写地址端口工作在 WB 级。如果直接把 IF/ID 中当前指令的 rd 接到写地址上，写入的就是”此刻在 ID 级那条指令”的 rd，而不是正在 WB 的那条指令的。因此 rd 字段必须经 ID/EX → EX/MEM → MEM/WB 逐级传递，在 WB 级再送回寄存器堆的写地址端口。

以 load 为例：在 IF 读出指令，ID 读寄存器后送入 ID/EX，EX 算地址后送入 EX/MEM，MEM 读出数据送入 MEM/WB，最后在 WB 把结果（连同一路传来的 rd）写回寄存器堆。

原则三：控制信号的产生与分组传递

控制信号的产生方式与单周期处理器相同（在 ID 级由控制单元根据操作码产生，见 04 单周期数据通路），但某些信号在后续阶段才用得上，而且每一级正在执行的指令不同。 因此控制信号在 ID 产生后按使用阶段分成 EX、MEM、WB 三组，存入 ID/EX；每过一级就”用掉”本级那一组，剩余的继续向后传：

flowchart LR
  CU[控制单元 Control<br/>ID 级产生] --> IDEX[ID/EX<br/>EX + MEM + WB]
  IDEX -->|EX 组在 EX 级使用| EXMEM[EX/MEM<br/>MEM + WB]
  EXMEM -->|MEM 组在 MEM 级使用| MEMWB[MEM/WB<br/>WB]
  MEMWB -->|WB 组在 WB 级使用| RF[寄存器堆写回]

正确的分组如下：

各类 RISC-V 指令在三组中的控制值（备份页内容）：

sd 和 beq 不写寄存器（RegWrite=0），所以 MemtoReg 无关（X）。

填充、满与排空

流水线深度（pipeline depth）是流水线的级数，本讲为 5。以下面 5 条指令为例（MIPS 写法）：

1000: lw  $8, 4($29)
1004: sub $2, $4, $5
1008: and $9, $10, $11
1012: or  $16, $17, $18
1016: add $13, $14, $0

逐周期看，第 $k$ 个周期第 1 条指令处于第 $k$ 级，后面的指令依次落后一级：

1. 填充（filling，周期 1–4）：流水线中还有未被使用的功能部件。周期 1 只有 lw 在 IF；周期 2 lw 在 ID、sub 在 IF；……周期 4 已有 4 条指令在 IF–MEM。
2. 满（full，周期 5）：五级各有一条指令，所有硬件都在使用——lw 在 WB，add 在 IF。
3. 排空（emptying，周期 6–9）：不再有新指令进入时，流水线逐级空出，add 在周期 9 完成写回。若后面还有源源不断的指令，流水线就能每个周期产出一条结果。

流水线悖论与加速比

流水线悖论（pipelining paradox）：流水线并不改善任何单条指令的延迟；事实上，每条指令在流水线中花的时间比在单周期数据通路中还要长。 原因有二：

1. 级间锁存增加延迟：每一级末尾都要经过一个流水线寄存器，数据必须在时钟沿前满足建立时间 $T_s$（并保持 $T_h$），时钟沿后还要经过 $T_{\rm clk\_q}$ 才出现在输出端。单周期只付一次这份开销，$k$ 级流水线要付 $k$ 次。
2. 最长的一级决定时钟周期：较短的级也必须等满整个周期。

于是每级周期满足（时序约束的推导见 03 数据通路部件与时钟）：

其中 $t_i$ 是第 $i$ 级组合逻辑延迟。下面的例题忽略锁存开销，只取 $\max_i t_i$。

理想加速比：流水线最多同时执行 5 条指令，若各级完全平衡（每级都是 $4.1/5=0.82$ ns），周期缩为原来的 1/5，理想加速比等于流水线深度 5。 实际只有 3.42，是因为各级不平衡——MEM 级 1.2 ns 远长于 WB 的 0.4 ns，其他级都要陪着等 1.2 ns。

流水线深度的极限：功耗

既然加速比理想上等于深度，自然的想法是不断加深流水线来提高吞吐量和主频。Intel x86 的历史正是如此：

• i486（1989）与 Pentium（1993）约 5 级，1997 年约 10 级；
• Willamette（2001）约 22 级、主频约 2 GHz，P4 Prescott（2004）达到约 31 级、主频约 3.6 GHz；
• 此后 Core 2 Conroe（2006）回落到 14 级，Core 2 Yorkfield（2008）与 Core i7 Gulftown（2010）约 16 级。

图：Intel x86 流水线深度与频率：从 i486 的 5 级升到 P4 Prescott 约 31 级，随后 Core 系列回落到 14–16 级。

回落的原因是功耗与发热：同时进行的事情太多，芯片会”熔化”。 必须关掉系统中暂时不用的部分，常见手段有：

1. 时钟门控（clock gating）：关闭空闲模块的时钟，其组合逻辑不再翻转，从而节省功耗。
2. 异步设计（asynchronous design）：不依赖全局时钟，需要时才工作。
3. 低电压摆幅（low voltage swings）/ 降压利用时序余量：若一级的 $T_{\rm clk\_q}$ + 传播延迟 + 建立时间明显短于时钟周期，中间就留有时间余量（slack），这段时间电路什么也不做。此时可以降低电源电压 $V_{dd}$，使电路变慢、恰好填满时钟周期，而动态功耗与 $V_{dd}^2$ 成正比，降压带来平方级的功耗下降。

flowchart LR
  A[发现时序余量 slack<br/>延迟 < 时钟周期] --> B[降低 Vdd]
  B --> C[电路变慢<br/>延迟恰好填满周期]
  B --> D[动态功耗随电压平方下降]

动态功耗与电压、频率的关系以及“功耗墙”的来龙去脉见 L01《05 技术趋势与功耗墙》，这里不再展开。

冒险与 RISC-V 的易流水化

加深流水线的第二个限制是冒险（hazard）：使下一条指令无法在其预定的时钟周期执行的情况。一旦出现冒险，指令只能停顿等待，流水线的吞吐量收益随之损失。 冒险分三类：

• 结构冒险（structural hazard）：硬件资源不够，两条指令同时要用同一部件——例如只有一个存储器时 IF 与 MEM 冲突。
• 数据冒险（data hazard）：指令的输入操作数依赖于前面指令尚未产生的结果。
• 控制冒险（control hazard）：分支结果未定，不知道下一条该取哪条指令。

结构冒险与数据冒险的具体分析与解决（停顿、转发、load-use）见 07 结构冒险与数据冒险，控制冒险见 08 控制冒险。

（备份页内容）RISC-V 指令集本身是按易于流水化设计的：

结构冒险与数据冒险

这部分源材料沿用 MIPS 写法（lw $1,4($2)、Rs/Rt、用 Rt 作 load 的目的寄存器），下面统一改写成 RISC-V：源寄存器记作 rs1/rs2，目的寄存器记作 rd，$1 对应 x1，lw 对应 ld。冒险的分类与定义见 06 流水线设计与性能，控制冒险见 08 控制冒险。

流水线图（Pipeline Diagram）

分析冒险首先要知道“第几个周期、哪条指令、用的是哪个部件”。流水线图（pipeline diagram）就是回答这个问题的工具：横轴是时钟周期，纵轴是按程序顺序排列的指令，每条指令画成 5 个部件符号——IM（取指，指令存储器）、Reg（译码并读寄存器堆）、ALU（执行）、DM（访存，数据存储器）、Reg（写回寄存器堆），下一条指令右移一格。

用流水线图可以回答三类问题：

1. 这段代码一共要多少个周期？
2. 第 4 个周期 ALU 在为哪条指令工作？
3. 有没有冒险？原因是什么？怎么解决？

5 条指令在五级流水线中没有冒险时占用第 1–9 个周期（$5 + (5-1) = 9$）。前 4 个周期在填充流水线；填满以后每个周期都有一条指令完成，所以 $\mathrm{CPI}=1$。

流水线会出问题，原因就是三类流水线冒险（分类见 06 流水线设计与性能）。所有冒险都可以靠等待解决，前提是流水线控制必须检测到冒险，再采取行动。

结构冒险（Structural Hazard）

结构冒险是两条不同的指令在同一时刻试图使用同一个硬件资源。 五级流水线中最典型的两个资源是存储器和寄存器堆。

单一存储器

以下面这段程序为例（下同）：

ld  x1, 4(x2)    # 指令 1
sub x4, x1, x5   # 指令 2
and x6, x1, x7   # 指令 3
or  x8, x1, x9   # 指令 4

在第 4 个周期，ld 处于 MEM 阶段，要从存储器读数据；同一周期 or 处于 IF 阶段，要从存储器读指令。如果指令和数据共用一个存储器，这两次访问就会冲突。

解决方法：把存储器分成指令存储器/指令缓存（I-cache）和数据存储器/数据缓存（D-cache）。IM 只在 IF 阶段使用，DM 只在 MEM 阶段使用，任何周期每个存储器最多只有一条指令在访问。

寄存器堆的读与写

第 5 个周期，ld 在 WB 阶段写寄存器堆，or 在 ID 阶段读寄存器堆，两者同时用到寄存器堆。

解决方法：把一个周期分成两半，前半周期写寄存器、后半周期读寄存器（并把读到的值装入流水线寄存器）。这样同一周期里先写进去的值，后半周期就能读到。 这个规则后面会反复用到：同一周期内 WB 写、ID 读同一个寄存器，读到的是新值。

三种数据相关：WAR、WAW 与 RAW

数据冒险是指令依赖于仍在流水线中的前一条指令的结果，在数据还没准备好时就去使用它。 设指令 I 在前、J 在后，按“哪种读写顺序被破坏”可分三类：

WAR 和 WAW 的两条指令之间其实没有数据依赖，只是碰巧用了同一个寄存器名字。把 J 的目的寄存器换成另一个寄存器，冲突就没了，这就是寄存器重命名（register renaming）。在别的实现技术中（或指令间距更长时），这两类冒险可能出现，这时可以用重命名解决。

RAW 不同：后一条指令要的是前一条指令写进寄存器的值，换名字解决不了，必须让数据真正从生产者送到消费者。下面只讨论 RAW。

RAW 冒险的时序与停顿（Stall）

两种 RAW 场景

场景一：寄存器使用（register usage）。

add x1, x2, x3   # 第 5 周期 WB 才写入 x1
sub x4, x1, x5   # 第 3 周期 ID 读 x1 → 读到旧值
and x6, x1, x7   # 第 4 周期 ID 读 x1 → 读到旧值
or  x8, x1, x9   # 第 5 周期 ID 读 x1 → 前半周期写、后半周期读，正确
xor x4, x1, x5   # 第 6 周期 ID 读 x1 → 正确

add 的结果要到第 5 个周期才写回 x1，sub 和 and 却在第 3、第 4 个周期就读寄存器，属于“写之前读”，读到的是错误的旧值。or 在第 5 个周期读，靠前半周期写、后半周期读拿到了正确值；xor 更晚，也没问题。

场景二：load-use 数据冒险。把第一条换成 ld x1, 4(x2)，情况相同：load 的数据也要到第 5 个周期才写回，sub、and 读错，or、xor 读对。 两种场景分开讲，是因为它们在转发下的结果不同，见下文。

解法一：停顿

停顿（stall）就是让相关指令原地等待，直到数据写回寄存器堆再读。sub 本来在第 3 个周期做 ID，必须推迟到与 add 的 WB 同一个周期（第 5 周期，靠半周期规则），所以要插入 2 个停顿周期；and 也随之整体后移。

停顿简单可靠，代价是 CPI 不再等于 1：每次停顿都让流水线空转，CPI 上升。

数据转发（Forwarding / Bypassing）

停顿浪费的周期其实没有必要：add 的结果在 EX 结束时（第 3 周期末）就已经算出来了，只是还没写回。转发（forwarding，又称旁路 bypassing）就是一旦结果产生，立即把它送到需要它的地方，不再等它写回寄存器堆。

精确地说：从流水线状态寄存器中最早出现该结果的位置取出它，送到这个周期需要它的功能部件（例如 ALU）。对 ALU 来说，输入不再只能来自 ID/EX，而可以来自任一流水线寄存器，硬件上需要：

1. 在 ALU 的两个输入端各加一个多路选择器；
2. 把 EX/MEM 和 MEM/WB 中准备写入 rd 的数据连到 EX 级 rs1、rs2 两个 ALU 选择器的输入端（可以接其中一个，也可以两个都接）；
3. 加上控制这些新选择器的硬件。

其他功能部件（如数据存储器 DM）可能也需要类似的转发逻辑。有了转发，即使存在数据相关，也能做到 $\mathrm{CPI}=1$。

流水线寄存器本来就保存着 ALU 结果：EX/MEM 中存着上一条指令刚算出的结果，下一个周期这个结果移到 MEM/WB。因此在 add x1,... 后面：

• 紧跟在后的 sub 在 EX 时，add 在 MEM，x1 的新值在 EX/MEM 中 → EX/MEM 转发；
• 中间隔一条的 and 在 EX 时，add 在 WB，x1 的新值已经到了 MEM/WB → MEM/WB 转发。

load-use：转发后仍要停顿 1 周期

load 的数据要到 MEM 阶段结束（第 4 周期末）才从数据存储器读出来，而紧跟其后的 sub 在第 4 周期开始时就要在 EX 用它。数据不能送回过去，所以即使有转发，也必须停顿 1 个周期：sub 推迟一拍进入 EX，这时 load 的数据已在 MEM/WB 中，可以转发过去。

转发单元与转发条件

EX/MEM 转发条件

转发单元在 EX 阶段比较寄存器号，判断 ALU 的某个输入是否应该改用流水线寄存器里的新值。EX/MEM 转发（生产者与使用者相邻，例如 add x1,x2,x3 之后紧跟 and x6,x1,x7）的条件是：

if (EX/MEM.RegWrite
    and (EX/MEM.RegisterRd != 0)
    and (EX/MEM.RegisterRd == ID/EX.RegisterRs1))
        ForwardA = 10

if (EX/MEM.RegWrite
    and (EX/MEM.RegisterRd != 0)
    and (EX/MEM.RegisterRd == ID/EX.RegisterRs2))
        ForwardB = 10

三个条件分别回答：

1. RegWrite：EX/MEM 中那条指令的结果真的会写回寄存器堆吗？（sd、beq 不写寄存器，它们的 rd 位置上的数没有意义。）
2. Rd ≠ 0：目的寄存器不是 x0 吗？x0 恒为 0，写 x0 的结果会被丢弃，绝不能转发给读 x0 的指令。
3. Rd == Rs：EX/MEM 中指令的目的寄存器与 ID/EX 中（正在进入 EX 的）指令的源寄存器相同吗？相同才真正构成数据冒险。

ForwardA 控制 ALU 第一个操作数（rs1）的选择器，ForwardB 控制第二个操作数（rs2）的选择器。

MEM/WB 转发条件（初版）

生产者与使用者中间隔一条指令（例如 add x1,x2,x3、一条无关指令、sub x4,x1,x5）时数据已在 MEM/WB，初版条件与上面同构，编码为 01：

if (MEM/WB.RegWrite
    and (MEM/WB.RegisterRd != 0)
    and (MEM/WB.RegisterRd == ID/EX.RegisterRs1))
        ForwardA = 01
（Rs2 同理 → ForwardB = 01）

这里的 RegWrite 问的是“MEM 阶段得到的数据会写回寄存器堆吗”，因此 MEM/WB 转发既能转发 ALU 结果，也能转发 load 读出的数据。

双重数据冒险

当 EX/MEM 和 MEM/WB 中的两条指令都要写同一个寄存器、且都与当前指令的源寄存器匹配时，双重数据冒险就出现了：该转发 WB 级那条指令的结果，还是 MEM 级那条指令的结果？

add x1, x1, x2   # x1 = 1 + 1 = 2
add x1, x1, x3   # x1 = 2 + 1 = 3
add x1, x1, x4   # x1 = 3 + 1 = 4

图：双重数据冒险：三条连续 add 都写寄存器 $1，第三条应转发最新的 EX/MEM 结果 3，而不是更旧的 MEM/WB 结果 2。

因此 MEM/WB 转发要再加一个条件：只有 EX/MEM 那一级不转发时，才从 MEM/WB 转发。源材料给出的修正条件只检查了 EX/MEM.RegisterRd != ID/EX.RegisterRs，这是简化写法。 完整条件（Patterson & Hennessy 版本）把 EX/MEM 转发的全部条件取反：