流水线

解析：

1. 参数定义

   • 流水线阶段数 $ k = 5 $
   • 指令数量 $ n = 100 $

2. 周期时间计算

   • 阶段延迟最大值：$ \max(150, 120, 150, 160, 140) = 160 \ \text{ns} $
   • 周期时间 $ t_p = 160 \ \text{ns} + 5 \ \text{ns} = 165 \ \text{ns} $

3. 总时间公式 $$ \text{总时间} = (k + n - 1) \times t_p = (5 + 100 - 1) \times 165 = 104 \times 165 = 17160 \ \text{ns} $$

• 关键分析：

  • 分支指令 I4 的执行结果需等待 EI 阶段完成后才能确定，因此流水线在此期间必须暂停。
  • 中间存储缓冲器延迟（1 ns）与阶段延迟共同构成每个周期的总耗时（10 ns + 1 ns = 11 ns/周期）。

• 流水线

• 时间计算：

  1. 前 7 个周期（从 I1 到 I4(EI) 完成）：
     $ 7 \text{ 周期} \times 11 \text{ ns/周期} = 77 \text{ ns} $
  2. 后 8 个周期（I9(FI) 到 I12(WO)）：
     $ 8 \text{ 周期} \times 11 \text{ ns/周期} = 88 \text{ ns} $

• 总计：
  $ 77 \text{ ns} + 88 \text{ ns} = 165 \text{ ns} $

关键分析步骤：

1. 非流水线总延迟
   各阶段延迟相加：
   5 + 6 + 11 + 8 = 30 ns

2. 流水线周期确定

   • 流水线周期由最长阶段延迟决定：max(5, 6, 11, 8) = 11 ns
   • 加上流水线寄存器开销：11 + 1 = 12 ns

3. 加速比计算

   $$\text{加速比} = \frac{\text{非流水线总延迟}}{\text{流水线周期}} = \frac{30}{12} = 2.5$$

注意事项

• 流水线寄存器的开销仅影响周期，不计入原始阶段延迟
• 稳定状态下的加速比反映单位时间内完成的指令数提升

解析

操作数转发（Operand Forwarding）：在这种技术中，操作数的值在被存储之前，就已经传递给了依赖该值的指令所需的流水线阶段。

在上面的问题中，指令 I2 依赖于 I0 和 I1，而指令 I3 则依赖于 I2。我们可以通过时间-空间图来更清楚地理解这个问题。

上图是一个指令在流水线中执行的时间-空间图。指令 I0 是一个乘法（MUL）操作，在 PO（执行）阶段需要 3 个时钟周期，在其他所有阶段仅需 1 个周期；指令 I1 是一个除法（DIV）操作，在 PO 阶段需要 6 个时钟周期，在其他阶段也只需 1 个周期。

我们可以注意到，即使在第 4 个时钟周期中 OF（取操作数）阶段是空闲的，指令 I1 也没有进入该阶段。这是一个设计问题。操作数的获取应该在即将进入执行阶段之前进行，否则可能会导致数据错误。由于下一个周期 PO 阶段尚未空闲，因此 OF 阶段被延迟，直到指令 I1 即将进入 PO 阶段前的那个周期才进行 OF。

指令 I2 是一个加法（ADD）操作，在所有阶段都只需 1 个时钟周期。但它是一个依赖操作，所需的操作数来自指令 I0 和 I1。指令 I2 需要使用 R5 和 R2 进行加法运算。R2 的值能够及时得到，因为当 I2 到达 PO 阶段时，R2 已经被写入内存。而 R5 则是另一个问题，因为 I2 的 PO 阶段与 I1 的 WO（写回）阶段是并行的，这意味着 I2 无法在执行之前从内存中获取 R5 的值。

这时就用到了操作数转发的概念。在指令 I1 将其结果（R5）写回内存之前，它可以先将该值转发给 I2 的执行缓冲区（Fetch-Execute Buffer），这样 I2 就可以在与 I1 写回阶段并行的时钟周期中使用该值，而不需要额外等待从内存中读取，从而节省了一个时钟周期。

同样的操作数转发机制也应用在指令 I3 上，它需要使用由 I2 计算得到的 R2 的值。通过转发机制，I3 可以提前获取该值，无需等待写回后再从内存中读取，因此同样节省了一个时钟周期。

所以，通过操作数转发机制，我们总共节省了 2 个时钟周期（I2 节省 1 个，I3 节省 1 个）。从图中可以看到整个流水线总共用了 15 个时钟周期，每个阶段的一个实例代表一个时钟周期，最终总共 15 个周期。

• I. 错误：旁路技术无法处理所有 RAW 冒险。例如，当某条指令依赖于 LOAD 指令的结果时，LOAD 会在存储访问阶段（MA）更新寄存器值，因此其数据在执行阶段（EX）无法直接获取。
• II. 正确：寄存器重命名可以消除所有 WAR 冒险。
• III. 错误：动态分支预测虽能减少控制冒险的惩罚，但无法完全消除。

解析

• 有效地址 是通过寻址方式计算得到的地址。
• 该地址仍为 虚拟地址，CPU 无法直接识别，需由内存管理单元（MMU）将其转换为对应的 物理地址。
• TLB（Translation Lookaside Buffer） 的作用是在地址翻译过程中进行旁路操作（“Lookaside” 指的是在主流程之外并行执行的操作）。
• 必须先获得 虚拟地址 才能进行 TLB 查找，因此数据 TLB 最早可在 有效地址计算完成后 被访问。

解释：指令周期阶段顺序

IF”  ID”  EX”  WB”

我们有 3 条指令，由于结果依赖性导致流水线等待。

上表展示了给定指令的周期阶段及所需周期数。所需总周期数=8，因此选项 B 正确。

解析

• 非流水线执行时间：6 个周期
• 流水线停顿影响：$25%$ 的指令导致 $2$ 个停顿周期
• 流水线时间计算： $$ 1 + \left(\frac{25}{100} \times 2\right) = 1.5 $$
• 速度提升比： $$ \frac{6}{1.5} = 4 $$

峰值时钟频率 = 1 / 最大延迟

各处理器中最大延迟最小的是 P3

即：

• P1：f = 1/2 = 0.5 GHz
• P2：f = 1/1.5 = 0.67 GHz
• P4：f = 1/1.1 GHz
• P3：f = 1/1 GHz = 1 GHz

因此 P3 是正确答案。

每条指令平均需要 1 个时钟周期。

关键计算步骤如下：

• 旧设计：

  • 时钟周期时间：2.2 ns（由 ID/RF 阶段决定）
  • 平均 CPI：$0.8 \times 1 + 0.2 \times 3 = 1.4$
  • 执行时间 $P = 1.4 \times 2.2 = 3.08$ ns

• 新设计：

  • 时钟周期时间：1 ns（由 EX1/EX2 阶段决定）
  • 平均 CPI：$0.8 \times 1 + 0.2 \times 6 = 2.0$
  • 执行时间 $Q = 2.0 \times 1 = 2.0$ ns

• 比值计算： $$ \frac{P}{Q} = \frac{3.08}{2.0} = 1.54 \approx 1.5 $$

结论：选择 A（1.5）。

解析：

1. 停顿周期计算

   • 条件分支在第 3 阶段确定结果，因此造成 2 个停顿周期（第 2、3 阶段无法继续取指）

2. 总惩罚周期

   • 条件分支占比：20% × 10⁹ = 2×10⁸ 条
   • 单条分支惩罚：2 个周期
   • 总惩罚周期 = 2×10⁸ × 2 = 4×10⁸ 周期

3. 基础执行时间

   • 总指令数：10⁹ 条
   • 频率：1GHz = 10⁹ 周期/秒
   • 基础时间 = 10⁹ / 10⁹ = 1 秒

4. 总执行时间

   • 惩罚时间 = 4×10⁸ / 10⁹ = 0.4 秒
   • 总时间 = 1 + 0.4 = 1.4 秒

解析：

• 不使用操作数前递时：

  T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11
  l1 IF RD EX MA WB
  l2    IF       RD EX MA WB
  l3             IF RD    EX MA  WB
  

• 使用操作数前递时：

  T1 T2 T3 T4 T5 T6 T7 T8
  l1 IF RD EX MA WB
  l2    IF RD EX MA WB
  l3       IF RD EX MA WB
  

综上，选项 A 正确。

解析：

• 阶段间延迟：每个阶段之间的寄存器延迟为 5 ns
• 第一个数据项延迟：为最大阶段延迟加上寄存器延迟后乘以级数： $$ (160 + 5) \times 4 = 660\ \text{ns} $$
• 后续数据项延迟：
  每个数据项仅需等待最长阶段时间（160 ns）与寄存器延迟之和： $$ 999 \times (160 + 5) = 999 \times 165\ \text{ns} $$
• 总延迟计算： $$ 660 + 999 \times 165 = 165,500\ \text{ns} = 165.5\ \mu\text{s} $$

解析

• A 项描述的是 数据冒险（Data Hazard），因为后续指令依赖前一条指令的计算结果。
• B 项涉及 控制冒险（Control Hazard），条件跳转可能导致流水线无法确定下一条指令。
• C 项属于 结构冒险（Structural Hazard），两条指令同时竞争同一 ALU 资源。
  因此，所有三项均会导致流水线冒险，正确答案为 D。

解析

1. 流水线阶段具有不同延迟

   • 理想情况下，流水线各阶段应具有均衡的延迟以实现最大吞吐量。若阶段延迟差异较大，会导致某些阶段成为瓶颈，降低整体效率。

2. 连续指令相互依赖

   • 数据依赖（如前一条指令的输出是下一条指令的输入）会引发数据冒险，迫使流水线暂停等待，造成性能损失。

3. 流水线阶段共享硬件资源

   • 资源冲突（如多条指令同时需要同一功能单元）会导致结构冒险，需通过插入空操作（NOP）或重命名寄存器解决，增加时延。

4. 综合影响

   • 上述三种情况均可能导致流水线阻塞、停顿或资源争用，从而降低处理器的并行度与性能。因此选项 (D) 正确。

解析

流水线技术不会增加单条指令的执行时间。它通过多级流水线并行执行指令来提升整体性能。

核心假设

• 在流水线和非流水线 CPU 中，每个阶段均耗时 T 单位时间
• 流水线 CPU 总阶段数 = 非流水线 CPU 总阶段数 = K
• 指令数量 N = 1

时间对比

• 流水线 CPU：总时间 $ T_1 = (K + (N - 1)) \times T = KT $
• 非流水线 CPU：总时间 $ T_2 = KN \times T = KT $

结论
当考虑流水线 CPU 中的缓冲延迟后，实际执行时间会略高于理论值，即 $ T_1 \geq T_2 $。因此选项 (B) 正确。

加速比 = 旧处理器的执行时间 / 新处理器的执行时间

• 旧处理器的执行时间
  $= \text{CPI} \times \text{周期时间}$
  $= 4 \times \frac{1}{2.5}\ \text{ns}$
  $= 1.6\ \text{ns}$

• 新处理器的执行时间

  • 流水线无停顿时 CPI ≈ 1
    $= 1 \times \frac{1}{2}\ \text{ns}$
    $= 0.5\ \text{ns}$

• 加速比计算
  $= \frac{1.6}{0.5} = 3.2$

给出的指令可以表示为：

I1: R1 = R2 + R3
I2: R7 = R1 * R3
I3: R4 = R1 - R5
I4: R3 = R2 + R4
I5: R7 = R8 * R9

反向依赖（Anti-dependence）定义

反向依赖（也称为写后读，WAR）是指某条指令需要某个值，但该值随后被更新的情况。

陈述分析

• S1: 指令 I2 和 I5 之间存在反向依赖。
  ❌ 错误。I2 和 I5 都写入 R7，不存在读后写的情况。

• S2: 指令 I2 和 I4 之间存在反向依赖。
  ✅ 正确。I2 读取 R3，而 I4 写入 R3。

• S3: 在指令流水线中，反向依赖总是导致停顿。
  ❌ 错误。反向依赖可以通过寄存器重命名消除。例如：

  1. B = 3
  N. B2 = B
  2. A = B2 + 1
  3. B = 7
  

  通过引入中间变量 B2，消除了原始代码中对 B 的反向依赖问题。

解析

对于该题，有以下流水线：

执行循环指令总共需要 23 个时钟周期。

公式
总执行时间 = (k + n – 1) × 最大时钟周期时间
其中 k = 流水线阶段总数，n = 指令总数

设计 D1

• k = 5
• n = 100
• 最大时钟周期时间 = 4 ns
• 总执行时间 = (5 + 100 - 1) × 4 = 416 ns

设计 D2

• k = 8
• n = 100
• 每个时钟周期时间 = 2 ns
• 总执行时间 = (8 + 100 - 1) × 2 = 214 ns

结论
节省时间 = 416 – 214 = 202 ns
因此选项 (B) 正确。

解析：

1. 初始吞吐量 $ T_1 $:

   $$ T_1 = \frac{1}{\text{最大延迟}} = \frac{1}{800} $$

2. 优化后吞吐量 $ T_2 $:

   $$ T_2 = \frac{1}{\text{新最大延迟}} = \frac{1}{600} $$

3. 吞吐量增长百分比： $$ \text{增长率} = \left( \frac{T_2 - T_1}{T_1} \right) \times 100% = \left( \frac{\frac{1}{600} - \frac{1}{800}}{\frac{1}{800}} \right) \times 100% = \left( \frac{1}{3} \right) \times 100% = 33.33% $$

答案选择最接近的 A。

逐步分析：

• 流水线原理：通过重叠指令执行提升吞吐量，但不会减少单条指令的执行时间。
• 瓶颈分析：UF 耗时 5ns（瓶颈），UG 耗时 3ns。各功能单元数量均为 2 个。
• 任务分配：
  • 每个功能单元需处理 5 个任务（共 10 个 Xi）。
  • G 计算从时间 0 开始，F 需等待 G 完成第一个元素（3ns 后）才能启动。
• 总耗时计算：
  1. UF 总耗时 = (5ns × 10 个任务) / 2 个单元 = 25ns
  2. 初始等待时间 = 3ns（G 第一个结果就绪时间）
  3. 最终总时间 = 3ns + 25ns = 28ns

另一种解法：

• 每个功能单元处理 5 个任务：
  • G 从时间 0 开始，F 在 3ns 后启动。
  • F 结束时间为：3ns + (5ns × 5 个任务) = 28ns

对于非流水线处理器，完成 1 条指令需要 12 个周期。因此，n 条指令需要 12n 个周期。
对于流水线处理器，每个阶段的时间 = max{各阶段周期} = max{3, 2, 5, 4, 6 和 2} = 6 个周期。因此，n 条指令需要：6×6 + (n-1)×6（第一条指令需要 6×6 个周期，其余 n-1 条每条增加 6 个周期）。
当指令数量趋近于无穷大时：

$$\lim_{n→\infty} [12n / (36 + 6(n-1))] = 12/6 = 2$$

解析：

1. 非流水线系统：
   各阶段耗时总和为 $2.5 + 1.5 + 2.0 + 1.5 + 2.5 = 10$ ns

2. 流水线系统：

   • 最大阶段延迟：$\max(2.5, 1.5, 2.0, 1.5, 2.5) = 2.5$ ns
   • 锁存器延迟：$0.5$ ns
   • 总周期时间：$2.5 + 0.5 = 3.0$ ns

3. 加速比计算： $$ \text{加速比} = \frac{\text{非流水线时间}}{\text{流水线时间}} = \frac{10}{3.0} = 3.33 $$

因此，总共需要 34 个周期 完成给定程序，每个周期耗时 (17+1 =) 18 ns。
所以总时间为 34 × 18 = 612 ns。

选项 (A) 正确。

已知指令格式大小为 2 字节（=16 位），因此指令编码总数为 $2^{16}$。整数操作数总位数为 $\log_2(16 \text{ 个整数寄存器}) = 4$，浮点操作数总位数为 $\log_2(64 \text{ 个浮点寄存器}) = 6$。消耗的编码数量如下：

• Type-1 指令：$4 \times 2^{3 \times 4} = 2^{14}$
• Type-2 指令：$8 \times 2^{2 \times 6} = 2^{15}$
• Type-3 指令：$14 \times 2^{(4+6)} = 14336$

剩余可用于 Type-4 指令的编码数量为：

$$ 2^{16} - (2^{14} + 2^{15} + 14336) = 2048 $$

因此，Type-4 指令的不同指令总数为：

$$ 2048 / 64 = \mathbf{32} $$

注意：不同指令与不同编码之间存在差异，单条指令在地址部分不同时可能对应多个编码。

解析：

• 2 个处理器：

  • 20% 的顺序工作由处理器 p1 完成（耗时 20 秒）
  • 剩余 80% 的工作平均分配给 p1 和 p2（各 40 秒）
  • 总耗时：20 + 40 = 60 秒

• 4 个处理器：

  • 20% 的顺序工作由任意一个处理器完成（耗时 20 秒）
  • 剩余 80% 的工作分配给 4 个处理器（各 20 秒）
  • 总耗时：20 + 20 = 40 秒

选项 D 正确。

解析

• 不同阶段延迟差异会引起 流水线阻塞（气泡）
• 连续指令依赖会引发 数据冒险
• 共享硬件资源则可能造成 结构冒险

因此所有选项均正确。

解析

非流水线处理器性能分析

• 时钟周期时间：
  $ T_{\text{non-pipeline}} = \frac{1}{2.5 \times 10^9} = 0.4 \ \text{ns} $
• 总时钟周期数：
  每条指令需 5 个周期，总指令数为 $ m $，则总周期数为 $ 5m $
• 总耗时：
  $ 5m \times 0.4 \ \text{ns} = 2m \ \text{ns} $

流水线处理器性能分析

• 时钟周期时间：
  $ T_{\text{pipeline}} = \frac{1}{2 \times 10^9} = 0.5 \ \text{ns} $
• 各指令类型周期开销：
  • 内存指令（占 30%）：
    • 5% 缓存未命中：$ 0.05 \times (50 + 1) = 2.55 $
    • 95% 正常访问：$ 0.95 \times 1 = 0.95 $
    • 平均周期数：$ 2.55 + 0.95 = 3.5 $
    • 总贡献：$ 0.3m \times 3.5 = 1.05m $
  • ALU 指令（占 60%）：
    • 无停顿，平均周期数为 1
    • 总贡献：$ 0.6m \times 1 = 0.6m $
  • 分支指令（占 10%）：
    • 50% 停顿：$ 0.5 \times (2 + 1) = 1.5 $
    • 50% 正常：$ 0.5 \times 1 = 0.5 $
    • 平均周期数：$ 1.5 + 0.5 = 2 $
    • 总贡献：$ 0.1m \times 2 = 0.2m $
• 总时钟周期数：
  $ 1.05m + 0.6m + 0.2m = 1.85m $
• 总耗时：
  $ 1.85m \times 0.5 \ \text{ns} = 0.925m \ \text{ns} $

加速比计算

$$ \text{加速比} = \frac{\text{非流水线耗时}}{\text{流水线耗时}} = \frac{2m}{0.925m} \approx 2.16 $$