vault backup: 2026-06-16 21:34:37

2026-06-16 21:34:37 +08:00
parent dcb3efa297
commit ff3343cb29
15 changed files with 2343 additions and 0 deletions
@@ -0,0 +1,58 @@
+---
+tags:
+  - 计算机系统结构
+  - 重点复习
+  - 索引
+create time: 2026-06-16 21:21
+---
+
+# 重点复习索引
+
+## 概述
+
+本文档为「计算机系统结构」期末考试重点复习指南。内容基于老师划定的考试重点，分为 **10 道小题**（概念理解与简答）和 **4 道大题**（计算与分析）两部分，共计 14 个专题文档。每道题目对应独立的复习文档，包含知识点详解、典型例题、解题思路与练习题。
+
+> [!tip] 使用建议
+> 1. **小题**侧重概念记忆与理解，建议先通读一遍建立知识框架
+> 2. **大题**侧重计算与分析，务必动手练习，对照答案验证
+> 3. 重点关注 [[小题3-控制冲突的解决措施|控制冲突]]、[[小题7-Cache不命中与3C模型|3C模型]] 和 [[大题3-非线性流水线调度|流水线调度]]——这三道是历年最高频考点
+> 4. 配合 [[计算机系统结构/复习文档/index|复习文档索引]] 中的详细讲解效果更佳
+
+## 小题目录（10 题）
+
+| 题号 | 文档 | 核心考点 | 参考页码 |
+|:----:|------|----------|:--------:|
+| 1 | [[小题1-冯氏分类法与并行度]] | Flynn 分类法、并行度从高到低排列 | P4-6 |
+| 2 | [[小题2-流水线的分类]] | 多功能/静态动态/线性非线性的含义与区别 | P55-56 |
+| 3 | [[小题3-控制冲突的解决措施]] | 分支指令延迟的有效措施 | P80 |
+| 4 | [[小题4-流水寄存器的作用]] | 流水寄存器（段间寄存器）的功能 | P86 |
+| 5 | [[小题5-指令级并发的开发方法]] | 静态方法与动态方法 | - |
+| 6 | [[小题6-组相联映射与标识存储器]] | 联想存储器、单体多字存储器、比较器个数 | P193 |
+| 7 | [[小题7-Cache不命中与3C模型]] | 强制性/容量/冲突不命中及对策 | P203-204 |
+| 8 | [[小题8-IO系统性能评价参数]] | 连接特性、容量、响应时间、吞吐率 | P239 |
+| 9 | [[小题9-总线仲裁与分离事务总线]] | 总线主设备、仲裁机制、分离事务总线 | P249 |
+| 10 | [[小题10-并行计算机系统结构分类]] | 集中式共享存储、分布式存储器多处理机 | P205 |
+
+## 大题目录（4 题）
+
+| 题号 | 文档 | 核心考点 | 参考例题 |
+|:----:|------|----------|:--------:|
+| 1 | [[大题1-CPU性能参数计算]] | CPI 计算、由 CPI 求 MIPS | 例1.3 |
+| 2 | [[大题2-指令操作编码方式]] | 定长/扩展操作码设计 | 习题2.13 |
+| 3 | [[大题3-非线性流水线调度]] | 预约表→禁止表→冲突向量→状态转移图→最优调度 | P65-67 |
+| 4 | [[大题4-Cache性能计算]] | 平均访存时间、CPU时间 | 例7.2, 习题7.10 |
+
+## 考试题型预测
+
+根据历年 A/B 卷风格，本次考试可能包含以下题型：
+
+| 题型 | 题量 | 分值 | 涉及知识点 |
+|------|:----:|:----:|------------|
+| 选择题 | 5~10 题 | 每题 2 分 | 小题 1~10 的基础概念 |
+| 判断题 | ~10 题 | 每题 1 分 | 基本概念辨析 |
+| 分析与设计题 | 3~4 题 | 每题 16~24 分 | 大题 1~4 的计算与分析 |
+| 论述题/综合题 | 1~2 题 | 每题 10~16 分 | 综合应用 |
+
+## 关联笔记
+- [[计算机系统结构/复习文档/index|复习文档索引]]
+- [[计算机系统结构/index|试题册索引]]
@@ -0,0 +1,189 @@
+---
+tags:
+  - 计算机系统结构
+  - 重点复习
+  - CPU性能
+  - CPI
+  - MIPS
+create time: 2026-06-16 21:21
+---
+
+# 大题 1 — CPU 性能参数计算
+
+## 概述
+
+本题考查 **CPU 性能参数**的计算方法，包括 **CPI**（每条指令平均时钟周期数）的计算、根据 CPI 求 **MIPS**（每秒百万条指令数），以及 CPU 执行时间的计算。这是课程最基础的计算题，几乎每年必考。
+
+> [!tip] 考试重点
+> 熟练掌握三个核心公式：$T = IC \times CPI \times \tau$、$MIPS = \frac{f}{CPI \times 10^6}$、$CPI = \sum_{i=1}^{n}(CPI_i \times F_i)$。计算时注意单位换算。
+
+## 正文
+
+### 一、核心公式体系
+
+```mermaid
+graph TD
+    T["CPU Time = IC x CPI x tau"] --> IC["IC: Instruction Count"]
+    T --> CPI["CPI: Cycles Per Instruction"]
+    T --> tau["tau: Clock Period"]
+
+    MIPS["MIPS = f / (CPI x 10^6)"] --> f["f: Clock Frequency"]
+    MIPS --> CPI2["CPI"]
+
+    T -->|"T = IC / (MIPS x 10^6)"| MIPS
+```
+
+#### 1.1 CPU 执行时间
+
+$$T_{CPU} = IC \times CPI \times \tau$$
+
+| 符号 | 含义 | 单位 |
+|:----:|------|------|
+| $T_{CPU}$ | CPU 执行时间 | 秒 (s) |
+| $IC$ | 指令条数 (Instruction Count) | 条 |
+| $CPI$ | 每条指令平均时钟周期数 | 周期/条 |
+| $\tau$ | 时钟周期时间 (Clock Period) | 秒/周期 |
+
+等价形式：
+
+$$T_{CPU} = \frac{IC \times CPI}{f}$$
+
+其中 $f = 1/\tau$ 为主频（单位 Hz）。
+
+#### 1.2 MIPS 的计算
+
+$$MIPS = \frac{f}{CPI \times 10^6}$$
+
+或者等价地：
+
+$$MIPS = \frac{IC}{T_{CPU} \times 10^6}$$
+
+| 符号 | 含义 | 单位 |
+|:----:|------|------|
+| $MIPS$ | 每秒百万条指令 | 百万条/秒 |
+| $f$ | 时钟频率 | Hz |
+| $CPI$ | 每条指令平均时钟周期数 | 周期/条 |
+
+#### 1.3 加权 CPI 的计算
+
+当程序包含多种类型的指令时，CPI 需要**加权平均**：
+
+$$CPI = \sum_{i=1}^{n} CPI_i \times F_i$$
+
+| 符号 | 含义 |
+|:----:|------|
+| $CPI_i$ | 第 $i$ 类指令的时钟周期数 |
+| $F_i$ | 第 $i$ 类指令在程序中的占比（频率） |
+| $n$ | 指令类型的数量 |
+
+### 二、典型例题（参考例 1.3）
+
+> [!example] 例题 1：由指令类型占比求 CPI 和 MIPS
+>
+> **题目**：某计算机有四类指令，各类指令的 CPI 和在程序中的比例如下：
+>
+> | 指令类型 | CPI | 占比 |
+> |:--------:|:---:|:----:|
+> | 算术逻辑 | 1 | 60% |
+> | Load/Store | 2 | 18% |
+> | 分支 | 4 | 12% |
+> | 访存 | 3 | 10% |
+>
+> 时钟频率为 500MHz。求：(1) 平均 CPI；(2) MIPS；(3) 执行 1000 万条指令需要多少时间？
+>
+> **解题步骤**：
+>
+> **Step 1：计算加权平均 CPI**
+>
+> $$CPI = 1 \times 0.60 + 2 \times 0.18 + 4 \times 0.12 + 3 \times 0.10$$
+> $$= 0.60 + 0.36 + 0.48 + 0.30 = \mathbf{1.74}$$
+>
+> **Step 2：计算 MIPS**
+>
+> $$MIPS = \frac{f}{CPI \times 10^6} = \frac{500 \times 10^6}{1.74 \times 10^6} = \frac{500}{1.74} \approx \mathbf{287.4}$$
+>
+> **Step 3：计算执行时间**
+>
+> $$T = \frac{IC}{MIPS \times 10^6} = \frac{10 \times 10^6}{287.4 \times 10^6} = \frac{10}{287.4} \approx \mathbf{0.0348 \text{ 秒}} \approx 34.8 \text{ ms}$$
+>
+> 或者直接：
+> $$T = IC \times CPI \times \tau = 10^7 \times 1.74 \times \frac{1}{500 \times 10^6} = 0.0348 \text{ 秒}$$
+
+> [!example] 例题 2：两种方案的性能对比（参考 A/B 卷风格）
+>
+> **题目**：同一程序在两种处理器 X 和 Y 上运行，时钟频率均为 2GHz。
+>
+> | 参数 | 方案 X | 方案 Y |
+> |:----:|:------:|:------:|
+> | 指令条数 IC | 50 亿条 | 10 亿条 |
+> | 平均 CPI | 1.2 | 5.0 |
+>
+> (1) 哪个方案执行时间更短？(2) MIPS 分别是多少？
+>
+> **解题步骤**：
+>
+> **Step 1：计算执行时间**
+>
+> $$T_X = \frac{IC \times CPI}{f} = \frac{5 \times 10^9 \times 1.2}{2 \times 10^9} = \mathbf{3.0 \text{ 秒}}$$
+>
+> $$T_Y = \frac{1 \times 10^9 \times 5.0}{2 \times 10^9} = \mathbf{2.5 \text{ 秒}}$$
+>
+> 方案 Y 更快，加速比 $= 3.0/2.5 = \mathbf{1.2}$ 倍。
+>
+> **Step 2：计算 MIPS**
+>
+> $$MIPS_X = \frac{2 \times 10^6}{1.2} \approx \mathbf{1666.7}$$
+>
+> $$MIPS_Y = \frac{2 \times 10^6}{5.0} = \mathbf{400.0}$$
+>
+> **分析**：方案 X 的 MIPS（1666.7）远高于方案 Y（400），但方案 X 的执行时间反而更长！这说明 **MIPS 不能单独作为性能比较指标**——它不考虑指令的功能复杂度差异。CPI 低不等于性能好，必须综合考虑 $IC \times CPI \times \tau$。
+
+### 三、MIPS 的局限性
+
+> [!warning] 考试常考
+> MIPS 的局限性包括：
+>
+> | 问题 | 说明 |
+> |------|------|
+> | 不同 ISA 不可比 | RISC 的 MIPS 通常高于 CISC，但不代表性能更好 |
+> | 不反映指令功能差异 | 一条复杂指令和一条简单指令在 MIPS 中等价 |
+> | 程序依赖性 | 不同程序在同一机器上的 MIPS 不同 |
+> | 可被人为优化 | 减少指令数量但增加 CPI 可能导致 MIPS 上升但性能下降 |
+
+### 四、练习题
+
+> [!example] 练习 1
+>
+> 某处理器主频 800MHz，执行某程序共 2000 条指令，平均 CPI 为 4。
+>
+> (1) CPU 执行时间是多少？(2) MIPS 是多少？
+>
+> > [!abstract]- 答案
+> > (1) $T = \frac{2000 \times 4}{800 \times 10^6} = \frac{8000}{8 \times 10^8} = 10^{-5} \text{ 秒} = 10 \text{ μs}$
+> >
+> > (2) $MIPS = \frac{800}{4} = 200$ 百万条/秒
+
+> [!example] 练习 2（A 卷原题改编）
+>
+> 某计算机主频 600MHz，执行 2000 条指令，每条指令平均时钟周期数为 4。求 MIPS。
+>
+> > [!abstract]- 答案
+> > $MIPS = \frac{f}{CPI \times 10^6} = \frac{600 \times 10^6}{4 \times 10^6} = \mathbf{150}$
+
+> [!example] 练习 3
+>
+> 某程序在处理器 A 上运行需要 10 秒，处理器 A 的主频为 2GHz，CPI 为 1.5。
+>
+> (1) 该程序有多少条指令？(2) 如果处理器 B 的主频为 3GHz，CPI 为 2.0，执行同一程序需要多长时间？
+>
+> > [!abstract]- 答案
+> > (1) $IC = \frac{T \times f}{CPI} = \frac{10 \times 2 \times 10^9}{1.5} \approx 1.333 \times 10^{10}$ 条
+> >
+> > (2) $T_B = \frac{1.333 \times 10^{10} \times 2.0}{3 \times 10^9} \approx \mathbf{8.89 \text{ 秒}}$
+> >
+> > 处理器 B 主频更高但 CPI 也更高，最终反而更慢！
+
+## 关联笔记
+- [[计算机系统结构/复习文档/计算机系统结构基础与定量原理]]
+- [[大题4-Cache性能计算]]
+- [[小题1-冯氏分类法与并行度]]
@@ -0,0 +1,230 @@
+---
+tags:
+  - 计算机系统结构
+  - 重点复习
+  - 指令系统
+  - 操作码编码
+create time: 2026-06-16 21:21
+---
+
+# 大题 2 — 指令操作编码方式
+
+## 概述
+
+本题考查**指令操作码的编码方式**，包括**定长操作码**和**扩展操作码**（等长扩展码）两种方案的设计与计算。这是指令系统设计的核心内容，是历年分析题的高频考点（A 卷、B 卷均有出现）。
+
+> [!tip] 考试重点
+> 掌握扩展操作码的**逐层展开**计算方法：从地址数最多的指令开始，每层计算可用编码空间，减去已用指令条数，剩余的作为扩展标志向下一层扩展。
+
+## 正文
+
+### 一、指令格式基础
+
+一条指令由**操作码**（Opcode）和**地址码**（Address Field）组成：
+
+```
+┌─────────────┬──────────┬──────────┬──────────┐
+│   操作码     │  地址码1  │  地址码2  │  地址码3  │
+└─────────────┴──────────┴──────────┴──────────┘
+```
+
+**约束条件**：指令字长固定，操作码位数 + 各地址码位数之和 = 指令字长
+
+> [!question] 为什么要使用扩展操作码？
+> 定长操作码对所有指令使用相同位数，但不同类型的指令需要的操作码空间不同。例如三地址指令只需要几条（操作码短），零地址指令可能需要很多条（操作码长）。扩展操作码允许不同类型的指令使用不同长度的操作码，在固定指令字长下支持**更多指令**。
+
+### 二、定长操作码
+
+所有指令的操作码位数**固定相同**。
+
+**操作码位数计算**：
+
+$$\text{操作码位数} = \text{指令字长} - \text{地址码总位数}$$
+
+**最大指令条数**：
+
+$$\text{最大指令条数} = 2^{\text{操作码位数}}$$
+
+> [!example] 定长操作码示例
+>
+> **已知**：指令字长 16 位，每个地址字段 6 位，设计双地址指令和单地址指令。
+>
+> **双地址指令**：操作码 = $16 - 6 \times 2 = 4$ 位，最多 $2^4 = 16$ 条。
+>
+> 如果需要 12 条双地址指令，剩余 $16 - 12 = 4$ 条留给单地址指令。
+>
+> **单地址指令**：操作码仍为 4 位（定长），最多 **4 条**。
+>
+> **问题**：单地址指令只能有 4 条——太少了！这就是定长操作码的局限。
+
+### 三、扩展操作码（等长扩展码）
+
+**核心思想**：操作码位数不固定，通过**保留编码**作为扩展标志，将地址码字段"借用"为操作码的一部分。
+
+#### 3.1 设计原则
+
+| 原则 | 说明 |
+|------|------|
+| 短操作码给高频指令 | 使用频率高的指令分配短操作码，减少平均指令长度 |
+| 扩展标志不冲突 | 短操作码的某些编码被保留作为"扩展标志"，告诉译码器继续读取后续字段作为操作码 |
+| 前缀不二义 | 短操作码不能是长操作码的前缀（否则译码歧义） |
+
+#### 3.2 计算方法
+
+> [!note] 逐层扩展的通用算法
+>
+> 设指令字长为 $W$ 位，每个地址字段为 $A$ 位。
+>
+> **第 1 层（三地址指令）**：
+> - 操作码位数 = $W - 3A$
+> - 最大编码空间 = $2^{W-3A}$
+> - 设需要 $k_1$ 条三地址指令，则保留 $2^{W-3A} - k_1$ 个扩展标志
+>
+> **第 2 层（二地址指令）**：
+> - 每个扩展标志可扩展 $A$ 位 → 新增 $A$ 位操作码
+> - 可用编码空间 = $(2^{W-3A} - k_1) \times 2^A$
+> - 设需要 $k_2$ 条二地址指令，保留 $(2^{W-3A} - k_1) \times 2^A - k_2$ 个扩展标志
+>
+> **第 3 层（单地址指令）**：
+> - 可用编码空间 = 上一层保留数 $\times 2^A$
+> - 设需要 $k_3$ 条，保留继续扩展
+>
+> **第 4 层（零地址指令）**：
+> - 操作码占满整个指令字长 $W$ 位
+> - 可用编码空间 = 上一层保留数 $\times 2^A$
+
+### 四、典型例题（参考习题 2.13）
+
+> [!example] 例题 1：扩展操作码设计（A 卷原题风格）
+>
+> **题目**：指令字长 12 位，每个地址字段 3 位。设计扩展操作码使系统支持：
+> - 4 条三地址指令
+> - 8 条二地址指令
+> - 190 条单地址指令
+>
+> 求各类指令的编码方案。
+>
+> **解题步骤**：
+>
+> **Step 1：三地址指令**
+>
+> 操作码位数 = $12 - 3 \times 3 = 3$ 位
+>
+> 编码空间 = $2^3 = 8$，需要 4 条 → 使用编码 `000` ~ `011`
+>
+> 保留扩展标志 = $8 - 4 = 4$ 个（编码 `100` ~ `111`）
+>
+> **Step 2：二地址指令**
+>
+> 操作码位数 = $3 + 3 = 6$ 位（前 3 位 + 借用地址字段 1 的 3 位）
+>
+> 可用编码空间 = $4 \times 2^3 = 32$，需要 8 条 → 使用 8 个编码
+>
+> 保留扩展标志 = $32 - 8 = 24$ 个
+>
+> **Step 3：单地址指令**
+>
+> 操作码位数 = $6 + 3 = 9$ 位（再借用地址字段 2 的 3 位）
+>
+> 可用编码空间 = $24 \times 2^3 = 192$
+>
+> 需要 190 条 → 使用 190 个编码，保留 $192 - 190 = 2$ 个扩展标志
+>
+> **Step 4：结果汇总**
+>
+> | 类型 | 操作码位数 | 地址字段位数 | 指令条数 |
+> |:----:|:---------:|:----------:|:-------:|
+> | 三地址 | 3 位 | $3 \times 3 = 9$ 位 | 4 条 |
+> | 二地址 | 6 位 | $2 \times 3 = 6$ 位 | 8 条 |
+> | 单地址 | 9 位 | $1 \times 3 = 3$ 位 | 190 条 |
+>
+> **验证**：$4 + 8 + 190 = 202$ 条指令。
+
+> [!example] 例题 2：求零地址指令最大数量（B 卷原题风格）
+>
+> **题目**：指令字长 16 位，每个地址字段 4 位。设计扩展操作码使得：
+> - 15 条三地址指令
+> - 15 条二地址指令
+> - 15 条单地址指令
+> - 零地址指令**尽可能多**
+>
+> **解题步骤**：
+>
+> **Step 1：三地址指令**
+>
+> 操作码位数 = $16 - 3 \times 4 = 4$ 位
+>
+> 编码空间 = $2^4 = 16$，用 15 条 → 保留 **1** 个扩展标志
+>
+> **Step 2：二地址指令**
+>
+> 可用编码 = $1 \times 2^4 = 16$，用 15 条 → 保留 **1** 个扩展标志
+>
+> **Step 3：单地址指令**
+>
+> 可用编码 = $1 \times 2^4 = 16$，用 15 条 → 保留 **1** 个扩展标志
+>
+> **Step 4：零地址指令**
+>
+> 可用编码 = $1 \times 2^4 = \mathbf{16}$ 条
+>
+> **结果汇总**：
+>
+> | 类型 | 操作码位数 | 指令条数 |
+> |:----:|:---------:|:-------:|
+> | 三地址 | 4 位 | 15 |
+> | 二地址 | 8 位 | 15 |
+> | 单地址 | 12 位 | 15 |
+> | 零地址 | 16 位 | **16** |
+>
+> 共计 $15 + 15 + 15 + 16 = 61$ 条指令。
+
+### 五、定长 vs 扩展操作码对比
+
+| 对比维度 | 定长操作码 | 扩展操作码 |
+|----------|:----------:|:----------:|
+| 译码复杂度 | 简单 | 较复杂 |
+| 指令空间利用 | 低（浪费位数） | 高（按需分配） |
+| 支持指令数量 | 少（受限于固定位数） | 多（灵活扩展） |
+| 平均指令长度 | 固定 | 可变（高频指令更短） |
+| 适用场景 | RISC（指令数量少、格式规整） | CISC（指令数量多、类型多样） |
+
+### 六、练习题
+
+> [!example] 练习 1（B 卷原题）
+>
+> 指令字长 16 位，地址字段 6 位。设计 12 条双地址指令，求：
+> (1) 定长操作码下最多可设计多少条单地址指令？
+> (2) 等长扩展码下最多可设计多少条单地址指令？
+>
+> > [!abstract]- 答案
+> > (1) 定长：操作码 4 位 → $2^4 - 12 = \mathbf{4}$ 条单地址指令
+> >
+> > (2) 扩展码：保留 4 个扩展标志 × $2^6 = 256$ → 最多 **256** 条单地址指令
+> >
+> > 扩展码的优势一目了然：从 4 条提升到 256 条！
+
+> [!example] 练习 2
+>
+> 指令字长 16 位，地址字段 4 位。要求设计：
+> - 12 条三地址指令
+> - 62 条二地址指令
+> - 30 条单地址指令
+> - 零地址指令尽可能多
+>
+> 求各类指令条数和总指令条数。
+>
+> > [!abstract]- 答案
+> > 三地址：操作码 4 位，$2^4=16$，用 12 条，保留 4 个
+> >
+> > 二地址：$4 \times 2^4 = 64$，用 62 条，保留 2 个
+> >
+> > 单地址：$2 \times 2^4 = 32$，用 30 条，保留 2 个
+> >
+> > 零地址：$2 \times 2^4 = \mathbf{32}$ 条
+> >
+> > 总计：$12 + 62 + 30 + 32 = \mathbf{136}$ 条
+
+## 关联笔记
+- [[计算机系统结构/复习文档/指令系统设计]]
+- [[大题1-CPU性能参数计算]]
@@ -0,0 +1,270 @@
+---
+tags:
+  - 计算机系统结构
+  - 重点复习
+  - 流水线
+  - 非线性流水线
+  - 调度
+create time: 2026-06-16 21:21
+---
+
+# 大题 3 — 非线性流水线调度
+
+## 概述
+
+本题考查**非线性流水线的调度**全过程：从**预约表**出发，提取**禁止表**、构建**冲突向量**、画出**状态转移图**、求**最优调度策略**，最后画**时空图**并计算**性能指标**（吞吐率、加速比、效率）。这是本课程**分值最高、难度最大**的核心考点。
+
+> [!tip] 考试重点
+> 这道题几乎每年必考（A 卷 24 分、B 卷 16 分），务必完整掌握以下流程：
+> **预约表 → 禁止表 → 冲突向量 → 状态转移图 → 最优调度 → 时空图 → 性能计算**
+
+## 正文
+
+### 一、完整解题流程
+
+```mermaid
+graph TD
+    A["Step 0: Reservation Table"] --> B["Step 1: Forbidden Set F"]
+    B --> C["Step 2: Initial Collision Vector C0"]
+    C --> D["Step 3: State Transition Diagram"]
+    D --> E["Step 4: Find Optimal Schedule"]
+    E --> F["Step 5: Space-Time Diagram"]
+    F --> G["Step 6: Performance Metrics"]
+
+    style A fill:#e3f2fd
+    style G fill:#e8f5e9
+```
+
+### 二、Step 0：预约表（Reservation Table）
+
+预约表记录**一个任务**在各时钟周期对各流水段的占用情况。`x` 表示占用，空表示空闲。
+
+> [!question] 预约表从哪来？
+> 预约表由任务的**执行过程**决定——它描述了单个任务在流水线中的资源使用模式。考试中预约表直接给出，不需要自己推导。
+
+### 三、Step 1：提取禁止表 $F$
+
+**规则**：对预约表中的**每一行**（每个流水段），找出该段被占用的所有时刻，计算每两个时刻之间的**时间间隔**，所有间隔的集合就是禁止表。
+
+$$F = \{d \mid \exists \text{某段在时刻 } t_1 \text{ 和 } t_2 \text{ 被占用，且 } d = |t_2 - t_1|\}$$
+
+> [!warning] 注意
+> - 只看**同一段**的多个占用时刻，不同段之间不比较
+> - 间隔取**绝对值**
+> - **去重**——相同的间隔只保留一个
+
+### 四、Step 2：构建初始冲突向量 $C_0$
+
+冲突向量是一个**二进制位串**，第 $i$ 位为 1 表示间隔 $i$ 禁止进入新任务。
+
+$$C_0[j] = \begin{cases} 1 & \text{if } j \in F \\ 0 & \text{if } j \notin F \end{cases}$$
+
+**位数** = 禁止表中的**最大间隔**值。
+
+> [!example] 示例：禁止表 $F = \{2, 4\}$
+>
+> 最大禁止间隔为 4，冲突向量共 4 位：
+>
+> | 位位置 | 4 | 3 | 2 | 1 |
+> |:------:|:-:|:-:|:-:|:-:|
+> | 值 | 1 | 0 | 1 | 0 |
+>
+> $C_0 = 1010$
+>
+> 含义：间隔 1 和 3 允许（位为 0），间隔 2 和 4 禁止（位为 1）。
+
+### 五、Step 3：画状态转移图
+
+对每个状态（冲突向量），找出**允许的间隔** $j$（对应位为 0），计算转移后的新状态：
+
+$$C_{new} = SHR^{(j)}(C_{current}) \lor C_0$$
+
+其中 $SHR^{(j)}$ 表示**右移 $j$ 位**（高位补 0），$\lor$ 表示**按位或**。
+
+**重复这个过程**直到所有可达状态都被探索。
+
+> [!note] 状态转移的直觉理解
+> - **右移 $j$ 位**：相当于"过了 $j$ 拍后，之前禁止的间隔距离缩短了 $j$"
+> - **或上 $C_0$**：新进入的任务带来了与第一个任务相同的禁止间隔
+> - 当所有位都为 1 时，该状态为**终态**——无法再进入新任务
+
+### 六、Step 4：求最优调度策略
+
+在状态转移图中找出所有**闭合回路**（从某状态出发回到自身），计算每个回路的**平均延迟**：
+
+$$\text{平均延迟} = \frac{\text{回路中各间隔之和}}{\text{回路长度（间隔个数）}}$$
+
+**平均延迟最小的回路**即为最优调度策略。
+
+> [!important] 找回路的技巧
+> 1. 从初始状态 $C_0$ 出发
+> 2. 列出所有可能的转移路径
+> 3. 找到回到 $C_0$ 的所有回路
+> 4. 比较各回路的平均延迟
+> 5. 注意：回路可以重复——如 (3, 2, 3, 2, ...) 只需取最小循环单元 (3, 2)
+
+### 七、完整例题（参考 A 卷 24 分大题）
+
+> [!example] 例题：4 段流水线调度
+>
+> **已知**预约表如下：
+>
+> | 段 \ 时刻 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
+> |:----------:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|
+> | $S_1$ | x | | | | x | | |
+> | $S_2$ | | x | | | | x | |
+> | $S_3$ | | | x | | | | x |
+> | $S_4$ | | | | x | | | |
+>
+> ---
+>
+> **Step 1：提取禁止表**
+>
+> | 段 | 占用时刻 | 间隔 |
+> |:--:|:--------:|:----:|
+> | $S_1$ | 1, 5 | $5-1=4$ |
+> | $S_2$ | 2, 6 | $6-2=4$ |
+> | $S_3$ | 3, 7 | $7-3=4$ |
+> | $S_4$ | 4 | 无间隔 |
+>
+> $$F = \{4\}$$
+>
+> ---
+>
+> **Step 2：构建初始冲突向量**
+>
+> 最大禁止间隔 = 4，冲突向量 4 位：
+>
+> $$C_0 = 1000$$
+>
+> | 位位置 | 4 | 3 | 2 | 1 |
+> |:------:|:-:|:-:|:-:|:-:|
+> | 值 | 1 | 0 | 0 | 0 |
+>
+> 允许间隔：$j \in \{1, 2, 3\}$
+>
+> ---
+>
+> **Step 3：计算状态转移**
+>
+> 从 $C_0 = 1000$ 出发：
+>
+> - $j=1$：$SHR^{(1)}(1000) \lor 1000 = 0100 \lor 1000 = 1100 = C_1$
+> - $j=2$：$SHR^{(2)}(1000) \lor 1000 = 0010 \lor 1000 = 1010 = C_2$
+> - $j=3$：$SHR^{(3)}(1000) \lor 1000 = 0001 \lor 1000 = 1001 = C_3$
+>
+> 从 $C_1 = 1100$（允许间隔 $j \in \{1, 2\}$，注意第 1 位和第 2 位为 0）：
+>
+> 等等，$C_1 = 1100$，第 1 位=0，第 2 位=0，所以允许 $j=1, 2$。
+>
+> - $j=1$：$SHR^{(1)}(1100) \lor 1000 = 0110 \lor 1000 = 1110 = C_4$
+> - $j=2$：$SHR^{(2)}(1100) \lor 1000 = 0011 \lor 1000 = 1011 = C_5$
+>
+> 从 $C_2 = 1010$（允许间隔 $j \in \{1, 3\}$）：
+>
+> - $j=1$：$SHR^{(1)}(1010) \lor 1000 = 0101 \lor 1000 = 1101 = C_6$
+> - $j=3$：$SHR^{(3)}(1010) \lor 1000 = 0001 \lor 1000 = 1001 = C_3$
+>
+> 从 $C_3 = 1001$（允许间隔 $j \in \{2, 3\}$）：
+>
+> - $j=2$：$SHR^{(2)}(1001) \lor 1000 = 0010 \lor 1000 = 1010 = C_2$
+> - $j=3$：$SHR^{(3)}(1001) \lor 1000 = 0001 \lor 1000 = 1001 = C_3$（自环）
+>
+> 从 $C_4 = 1110$（允许间隔 $j=1$）：
+>
+> - $j=1$：$SHR^{(1)}(1110) \lor 1000 = 0111 \lor 1000 = 1111 = C_7$（终态）
+>
+> 从 $C_5 = 1011$（允许间隔 $j=2$）：
+>
+> - $j=2$：$SHR^{(2)}(1011) \lor 1000 = 0010 \lor 1000 = 1010 = C_2$
+>
+> 从 $C_6 = 1101$（允许间隔 $j=2$）：
+>
+> - $j=2$：$SHR^{(2)}(1101) \lor 1000 = 0011 \lor 1000 = 1011 = C_5$
+>
+> ---
+>
+> **Step 4：画状态转移图**
+>
+> ```mermaid
+> stateDiagram-v2
+>     direction LR
+>     [*] --> C0
+>     C0 --> C1: "j=1"
+>     C0 --> C2: "j=2"
+>     C0 --> C3: "j=3"
+>     C1 --> C4: "j=1"
+>     C1 --> C5: "j=2"
+>     C2 --> C6: "j=1"
+>     C2 --> C3: "j=3"
+>     C3 --> C2: "j=2"
+>     C3 --> C3: "j=3"
+>     C4 --> C7: "j=1"
+>     C5 --> C2: "j=2"
+>     C6 --> C5: "j=2"
+> ```
+>
+> ---
+>
+> **Step 5：找最优调度策略**
+>
+> 从 $C_0$ 出发的所有闭合回路：
+>
+> | 回路 | 间隔序列 | 平均延迟 |
+> |:----:|:--------:|:--------:|
+> | $C_0 \to C_3 \to C_3$ (自环) | (3) | $3/1 = 3.0$ |
+> | $C_0 \to C_3 \to C_2 \to C_3$ | (3, 2) | $(3+2)/2 = 2.5$ |
+> | $C_0 \to C_2 \to C_3 \to C_2$ | (2, 3) | $(2+3)/2 = 2.5$ |
+> | $C_0 \to C_1 \to C_5 \to C_2 \to C_3$ | (1, 2, 2, 3) | $8/4 = 2.0$ |
+>
+> ... 需要检查是否回路回到 $C_0$。由于本例中从 $C_0$ 出发不一定回到 $C_0$，需要选取**最小平均延迟的循环回路**。
+>
+> **最优调度策略**：间隔序列为 **(3, 2)**，平均延迟 **2.5 拍**。
+>
+> ---
+>
+> **Step 6：画时空图（4 个任务）**
+>
+> 按调度策略 (3, 2, 3, 2, ...)，任务进入时刻：0, 3, 5, 8
+>
+> | 段 \ 时刻 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
+> |:----------:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:-:|:--:|:--:|:--:|
+> | $S_1$ | $T_1$ | | | | | $T_2$ | | | | | $T_3$ | | |
+> | $S_2$ | | $T_1$ | | | | | $T_2$ | | | | | $T_3$ | |
+> | $S_3$ | | | $T_1$ | | | | | $T_2$ | | | | | $T_3$ |
+> | $S_4$ | | | | $T_1$ | | | | | $T_2$ | | | | |
+>
+> （续表：任务 $T_4$ 在时刻 10 进入...）
+>
+> ---
+>
+> **Step 7：计算性能指标**
+>
+> 4 个任务总完成时间 = 最后一个任务进入时刻 + 单个任务执行时间 = $8 + 4 = 12$ 拍
+>
+> - **吞吐率**：$TP = \frac{4}{12} = \frac{1}{3}$ 任务/拍
+> - **串行执行时间**：$T_{seq} = 4 \times 4 = 16$ 拍
+> - **加速比**：$S = \frac{T_{seq}}{T_k} = \frac{16}{12} = 1.33$
+> - **效率**：$E = \frac{S}{k} = \frac{1.33}{4} = 33.3\%$（$k$ 为段数）
+
+### 八、性能指标公式汇总
+
+| 指标 | 公式 | 说明 |
+|------|------|------|
+| **吞吐率** | $TP = \frac{n}{T_k}$ | $n$ 个任务在 $T_k$ 时间完成 |
+| **加速比** | $S = \frac{T_{seq}}{T_k} = \frac{n \times k \times \Delta t}{T_k}$ | 串行时间 / 流水线时间 |
+| **效率** | $E = \frac{S}{k}$ | 流水线利用率 |
+
+其中 $T_k = (n-1) \times \text{平均延迟} + k \times \Delta t$（$k$ 为段数，$\Delta t$ 为时钟周期）。
+
+> [!warning] 考试常见错误
+> 1. 提取禁止表时**只看同一行**的间隔，不要跨行比较
+> 2. 冲突向量的位数 = **最大禁止间隔**，不是禁止表的元素个数
+> 3. 状态转移公式是 **右移**（不是左移），且要 **或上 $C_0$**
+> 4. 最优调度是平均延迟**最小**的回路，不是总延迟最小的
+> 5. 画时空图时注意：每个任务的各段占用时刻必须与预约表一致
+
+## 关联笔记
+- [[计算机系统结构/复习文档/流水线技术]]
+- [[小题2-流水线的分类]]
+- [[小题4-流水寄存器的作用]]
@@ -0,0 +1,269 @@
+---
+tags:
+  - 计算机系统结构
+  - 重点复习
+  - Cache
+  - 性能计算
+create time: 2026-06-16 21:21
+---
+
+# 大题 4 — Cache 性能计算
+
+## 概述
+
+本题考查 **Cache 的性能计算**，包括**平均访存时间**（AMAT）、**CPU 时间**的计算，以及**分离 Cache vs 混合 Cache** 的性能对比。这是 Cache 专题的核心计算题，历年考试中频繁出现。
+
+> [!tip] 考试重点
+> 核心公式 `AMAT = 命中时间 + 不命中率 × 不命中开销` 必须烂熟于心。分离 Cache 与混合 Cache 的对比计算是 A 卷原题（16 分），务必反复练习。
+
+## 正文
+
+### 一、核心公式体系
+
+```mermaid
+graph TD
+    AMAT["AMAT = Hit Time + Miss Rate x Miss Penalty"]
+    AMAT --> HT["Hit Time"]
+    AMAT --> MR["Miss Rate"]
+    AMAT --> MP["Miss Penalty"]
+
+    CPU["CPU Time = IC x (CPIexe + Mem x MR x MP) x tau"]
+    CPU --> IC["IC: Instruction Count"]
+    CPU --> CPI["CPIexe: Base CPI"]
+    CPU --> MEM["Mem: Memory Access per Instruction"]
+    CPU --> tau["tau: Clock Period"]
+```
+
+#### 1.1 平均访存时间
+
+$$AMAT = \text{命中时间} + \text{不命中率} \times \text{不命中开销}$$
+
+| 符号 | 含义 | 典型单位 |
+|:----:|------|:--------:|
+| $AMAT$ | 平均访存时间 | 周期 / ns |
+| 命中时间 | Cache 命中时的访问时间 | 周期 |
+| 不命中率 | 访问不命中的概率 | % |
+| 不命中开销 | 不命中时从下级存储取数据的代价 | 周期 |
+
+#### 1.2 多级 Cache 的 AMAT
+
+$$AMAT = HT_{L1} + MR_{L1} \times (HT_{L2} + MR_{L2} \times MP_{L2})$$
+
+> [!note] 全局不命中率 vs 局部不命中率
+> - **局部不命中率**：该级 Cache 自身的不命中率 = 该级不命中次数 / 该级总访问次数
+> - **全局不命中率**：该级 Cache 的不命中率 = 该级不命中次数 / **CPU 总访存次数**
+> - $MR_{global,L2} = MR_{L1} \times MR_{L2,local}$
+
+#### 1.3 CPU 时间与 Cache 的关系
+
+$$CPU 时间 = IC \times (CPI_{exe} + \text{每条指令访存次数} \times \text{不命中率} \times \text{不命中开销}) \times \tau$$
+
+等价地：
+
+$$CPU 时间 = IC \times CPI_{eff} \times \tau$$
+
+其中 $CPI_{eff} = CPI_{exe} + \text{访存 stall CPI}$
+
+$$\text{访存 stall CPI} = \text{每条指令访存次数} \times \text{不命中率} \times \text{不命中开销}$$
+
+### 二、分离 Cache vs 混合 Cache（A 卷原题）
+
+> [!example] 例题 1（参考例 7.2 / A 卷 16 分大题）
+>
+> **已知条件**：
+> - 程序中 78% 为取指令访问，22% 为数据访问（load/store）
+> - 不命中开销均为 40 周期
+>
+> **方案一：分离 Cache**（指令 16KB + 数据 16KB = 共 32KB）
+> - 指令 Cache 不命中率 $mr_I = 1\%$
+> - 数据 Cache 不命中率 $mr_D = 5\%$
+> - 命中时间 = 1 周期（独立端口，无冲突）
+>
+> **方案二：混合 Cache**（统一 32KB）
+> - 整体不命中率 $mr = 1.5\%$
+> - 取指命中时间 = 1 周期
+> - load/store 命中时间 = **2 周期**（共享端口，需额外仲裁）
+>
+> **问题**：哪种方案的平均访存时间更短？
+>
+> ---
+>
+> **Step 1：分离 Cache 的平均访存时间**
+>
+> $$AMAT_{分离} = 78\% \times (1 + 0.01 \times 40) + 22\% \times (1 + 0.05 \times 40)$$
+>
+> $$= 0.78 \times (1 + 0.4) + 0.22 \times (1 + 2.0)$$
+>
+> $$= 0.78 \times 1.4 + 0.22 \times 3.0$$
+>
+> $$= 1.092 + 0.660 = \mathbf{1.752 \text{ 周期}}$$
+>
+> ---
+>
+> **Step 2：混合 Cache 的平均访存时间**
+>
+> $$AMAT_{混合} = 78\% \times (1 + 0.015 \times 40) + 22\% \times (2 + 0.015 \times 40)$$
+>
+> $$= 0.78 \times (1 + 0.6) + 0.22 \times (2 + 0.6)$$
+>
+> $$= 0.78 \times 1.6 + 0.22 \times 2.6$$
+>
+> $$= 1.248 + 0.572 = \mathbf{1.820 \text{ 周期}}$$
+>
+> ---
+>
+> **Step 3：比较与结论**
+>
+> | 方案 | 平均访存时间 |
+> |:----:|:----------:|
+> | 分离 Cache | **1.752** 周期 |
+> | 混合 Cache | 1.820 周期 |
+>
+> **分离 Cache 更优**（1.752 < 1.820），虽然混合 Cache 的不命中率更低（1.5% < 加权 1.88%），但 load/store 的额外命中时间（+1 周期）抵消了这个优势。
+
+> [!question] 什么时候混合 Cache 更好？
+> 如果 load/store 的额外命中时间**小于 1 周期**（如 0.5 周期），或者混合 Cache 的不命中率**显著低于**分离方案（如 0.5% vs 1.88%），混合方案可能更优。具体需要代入数值计算。
+
+### 三、CPI 与 Cache 性能的综合计算
+
+> [!example] 例题 2（参考习题 7.10 / B 卷 16 分大题风格）
+>
+> **已知条件**：
+> - 处理器基本 CPI（理想 Cache 无缺失）= 2.5
+> - 时钟周期 = 2 ns
+> - 每条指令平均访存 1.5 次
+> - 不命中开销 = 90 个时钟周期
+> - 命中时间 = 1 个时钟周期
+>
+> **方案 A：直接映像 Cache** → 不命中率 1.5%
+>
+> **方案 B：两路组相联 Cache** → 不命中率 1.2%，但时钟周期增加 10%
+>
+> 选择哪个方案？
+>
+> ---
+>
+> **Step 1：方案 A — 直接映像**
+>
+> 时钟周期 = 2 ns（不变）
+>
+> $$AMAT_A = 1 + 0.015 \times 90 = 1 + 1.35 = 2.35 \text{ 周期}$$
+>
+> $$CPI_{eff,A} = 2.5 + 1.5 \times 0.015 \times 90 = 2.5 + 2.025 = 4.525$$
+>
+> $$CPU 时间_A = IC \times 4.525 \times 2\text{ns} = 9.05 \times IC \text{ (ns)}$$
+>
+> ---
+>
+> **Step 2：方案 B — 两路组相联**
+>
+> 时钟周期 = $2 \times 1.1 = 2.2$ ns（增加 10%）
+>
+> $$AMAT_B = 1 + 0.012 \times 90 = 1 + 1.08 = 2.08 \text{ 周期}$$
+>
+> $$CPI_{eff,B} = 2.5 + 1.5 \times 0.012 \times 90 = 2.5 + 1.62 = 4.12$$
+>
+> $$CPU 时间_B = IC \times 4.12 \times 2.2\text{ns} = 9.064 \times IC \text{ (ns)}$$
+>
+> ---
+>
+> **Step 3：比较与结论**
+>
+> | 方案 | CPI | 时钟(ns) | CPU 时间(ns/IC) | AMAT(周期) |
+> |:----:|:---:|:--------:|:---------------:|:----------:|
+> | 直接映像 | 4.525 | 2.0 | **9.050** | 2.35 |
+> | 两路组相联 | 4.12 | 2.2 | 9.064 | 2.08 |
+>
+> 虽然两路组相联的 AMAT 更低（2.08 < 2.35），但由于**时钟周期增长 10%**，最终 CPU 时间反而略高（9.064 > 9.050）。
+>
+> **结论**：选择**直接映像 Cache**。性能差异很小（0.15%），但直接映像硬件更简单、面积更小、功耗更低。
+
+> [!note] B 卷原题的另一种计算方式
+>
+> B 卷原题中给出的条件略有不同（命中时间为 0.8 周期），计算过程：
+>
+> $$AMAT = 0.8 + MR \times 90$$
+>
+> 需要将 AMAT 转换为 ns 后再计算 CPU 时间：
+>
+> $$CPU 时间 = IC \times (CPI \times \tau + \text{访存次数} \times MR \times MP \times \tau)$$
+
+### 四、地址位分解计算
+
+> [!example] 例题 3：地址位分解（配合选择题/填空题）
+>
+> **已知**：32 位地址，Cache 容量 32KB，块大小 64B，8 路组相联。
+>
+> | 字段 | 位数 | 计算方法 |
+> |:----:|:----:|----------|
+> | Offset | 6 | $\log_2(64) = 6$ |
+> | Set Index | 6 | $\log_2(\frac{32\text{KB}}{64\text{B} \times 8}) = \log_2(64) = 6$ |
+> | Tag | 20 | $32 - 6 - 6 = 20$ |
+>
+> **关键步骤**：
+> 1. 先算 Offset = $\log_2$(块大小)
+> 2. Cache 行数 = Cache 容量 / 块大小 = $32\text{KB} / 64\text{B} = 512$
+> 3. 组数 = Cache 行数 / 相联度 = $512 / 8 = 64$
+> 4. Set Index = $\log_2$(组数) = $\log_2(64) = 6$
+> 5. Tag = 地址总位数 - Set Index - Offset = $32 - 6 - 6 = 20$
+
+### 五、练习题
+
+> [!example] 练习 1
+>
+> 某处理器 CPI = 2.0，时钟 1GHz，每条指令访存 1.4 次。Cache 命中时间 1 周期，不命中率 3%，不命中开销 50 周期。求有效 CPI 和 CPU 执行 10^8 条指令的时间。
+>
+> > [!abstract]- 答案
+> > 访存 stall CPI $= 1.4 \times 0.03 \times 50 = 2.1$
+> >
+> > 有效 CPI $= 2.0 + 2.1 = \mathbf{4.1}$
+> >
+> > CPU 时间 $= 10^8 \times 4.1 / (10^9) = \mathbf{0.41 \text{ 秒}} = 410 \text{ ms}$
+
+> [!example] 练习 2
+>
+> 分离 Cache：指令 8KB（不命中率 0.8%），数据 8KB（不命中率 4%）。程序 70% 取指，30% 数据访问。不命中开销 100 周期，命中时间 1 周期。求平均访存时间。
+>
+> > [!abstract]- 答案
+> > $AMAT = 70\% \times (1 + 0.008 \times 100) + 30\% \times (1 + 0.04 \times 100)$
+> >
+> > $= 0.7 \times 1.8 + 0.3 \times 5.0 = 1.26 + 1.50 = \mathbf{2.76 \text{ 周期}}$
+
+> [!example] 练习 3（综合）
+>
+> 某程序 $10^6$ 条指令，CPI = 1.8，时钟 2GHz，每条指令平均访存 1.2 次。
+>
+> | Cache 方案 | 容量 | 不命中率 | 命中时间 | 不命中开销 |
+> |:----------:|:----:|:--------:|:--------:|:----------:|
+> | A | 16KB | 4% | 1 周期 | 80 周期 |
+> | B | 32KB | 2% | 2 周期 | 80 周期 |
+>
+> 哪个方案的 CPU 时间更短？
+>
+> > [!abstract]- 答案
+> > A: $CPI_{eff} = 1.8 + 1.2 \times 0.04 \times 80 = 1.8 + 3.84 = 5.64$
+> >
+> > $T_A = 10^6 \times 5.64 / (2 \times 10^9) = 2.82$ ms
+> >
+> > B: $CPI_{eff} = 1.8 + 1.2 \times 0.02 \times 80 = 1.8 + 1.92 = 3.72$
+> >
+> > $T_B = 10^6 \times 3.72 / (2 \times 10^9) = 1.86$ ms
+> >
+> > 方案 B 更优（1.86 ms < 2.82 ms），虽然命中时间更长但不命中率低很多。
+
+### 六、3C 模型与优化技术对应表
+
+| 不命中类型 | 原因 | 优化技术 | 对 AMAT 的影响 |
+|:----------:|------|----------|----------------|
+| 强制性 | 首次访问 | 增大块大小、预取 | 减少不命中率 |
+| 容量 | Cache 太小 | 增大容量 | 减少不命中率 |
+| 冲突 | 映射冲突 | 提高相联度、Victim Cache | 减少不命中率 |
+
+> [!warning] 权衡思维
+> 几乎每种优化都有副作用：增大块大小可能增加不命中开销；提高相联度增加命中时间；增大容量增加命中时间和成本。考试中需要**计算后比较**，不能只看一个指标。
+
+## 关联笔记
+- [[计算机系统结构/复习文档/存储系统与Cache]]
+- [[小题7-Cache不命中与3C模型]]
+- [[小题6-组相联映射与标识存储器]]
+- [[大题1-CPU性能参数计算]]
@@ -0,0 +1,102 @@
+---
+tags:
+  - 计算机系统结构
+  - 重点复习
+  - Flynn分类
+  - 并行度
+create time: 2026-06-16 21:21
+---
+
+# 小题 1 — 冯氏分类法与并行度排列
+
+## 概述
+
+本题考查 **Flynn（冯氏）分类法** 的四种类型及其**并行度从高到低的排列**。Flynn 分类法是计算机系统结构最基本的分类方法，几乎每年必考（选择题/判断题）。
+
+> [!tip] 考试重点
+> 重点掌握 MIMD > SIMD > SISD 的并行度排序，理解 MISD 为什么在实际中不存在。选择题常考"哪个不存在"和"多处理机属于哪种类型"。
+
+## 正文
+
+### 一、Flynn 分类法的基本原理
+
+Flynn（1966）按照**指令流**（Instruction Stream）和**数据流**（Data Stream）的多倍性将计算机系统分为四类：
+
+| 分类维度 | 单倍性 | 多倍性 |
+|:--------:|:------:|:------:|
+| **指令流** | 一次只执行一条指令 | 同时执行多条不同指令 |
+| **数据流** | 一次只处理一个数据 | 同时处理多个数据 |
+
+### 二、四种类型详解
+
+| 类型 | 全称 | 指令流 | 数据流 | 并行度 | 典型代表 |
+|:----:|------|:------:|:------:|:------:|----------|
+| **SISD** | Single Instruction, Single Data | 单 | 单 | **最低** | 传统单处理器 |
+| **SIMD** | Single Instruction, Multiple Data | 单 | 多 | **中等** | 向量处理器、GPU |
+| **MISD** | Multiple Instruction, Single Data | 多 | 单 | **理论分类** | 无实际计算机 |
+| **MIMD** | Multiple Instruction, Multiple Data | 多 | 多 | **最高** | 多处理器、集群 |
+
+> [!question] 思考：为什么 SIMD 的并行度比 SISD 高？
+> SIMD 虽然只有一条指令流，但这条指令**同时作用于多个数据**。例如向量加法 `C = A + B`，SIMD 处理器可以同时对 64 个元素对进行加法，相当于同时完成了 64 个操作。而 SISD 一次只能处理一个元素对。
+
+### 三、并行度从高到低排列
+
+$$\text{MIMD} > \text{SIMD} > \text{SISD}$$
+
+> [!abstract]- 答案
+> **并行度排序：MIMD > SIMD > SISD**。MISD 为理论分类，无实际计算机，通常不参与排序。
+
+> [!note] 排序理由
+>
+> **MIMD 并行度最高**：多个处理器各自独立执行不同的指令流处理不同的数据流。每个处理器都能独立工作，既有指令级并行又有数据级并行。例如 32 个处理器的集群，每个处理器同时运行不同的程序。
+>
+> **SIMD 并行度中等**：虽然只有一条指令流，但该指令同时作用于多个数据元素。并行度取决于数据通道宽度（如一次处理 128/256/512 位数据）。GPU 的一个 warp/wavefront 就是典型的 SIMD 执行模式。
+>
+> **SISD 并行度最低**：传统的单处理器，一次执行一条指令处理一个数据。虽然现代处理器内部有流水线、超标量等技术，但从 Flynn 分类的视角看仍是 SISD。
+>
+> **MISD 不参与排序**：多条指令同时处理同一数据——这种场景在实际中几乎不存在。某些容错计算机（如航天系统中对同一数据用多个独立算法验证）被**部分学者**归为 MISD，但学界主流观点认为 MISD 仅为理论分类。
+
+### 四、各类的典型代表与特征对比
+
+```mermaid
+graph TD
+    ROOT["Flynn Classification"] --> U["Uniprocessor"]
+    ROOT --> P["Multiprocessor"]
+
+    U --> SISD["SISD: Traditional CPU"]
+    U --> SIMD["SIMD: Vector/GPU"]
+    P --> MISD["MISD: Theoretical Only"]
+    P --> MIMD["MIMD: Multi-CPU/Cluster"]
+
+    SIMD --> SIMD_APP["Matrix, Image Processing"]
+    MIMD --> MIMD_APP["Server, Supercomputer"]
+```
+
+| 特征 | SISD | SIMD | MISD | MIMD |
+|------|:----:|:----:|:----:|:----:|
+| 控制单元数量 | 1 | 1 | 多 | 多 |
+| 处理器数量 | 1 | 多 | 多 | 多 |
+| 指令同步 | 不需要 | 需要严格同步 | 复杂 | 独立执行 |
+| 编程难度 | 低 | 中（需向量化） | - | 高（需并行编程） |
+| 实际存在 | 是 | 是 | **否** | 是 |
+
+> [!question] 现代处理器属于哪种类型？
+> 现代多核处理器（如 Intel i7 的 8 核）从 Flynn 分类看属于 **MIMD**——每个核心可以独立执行不同的指令流。但单个核心内部的 SIMD 扩展（如 AVX-512）使每个核心也具备 SIMD 能力。因此现代处理器是 **MIMD + SIMD 的混合体**。
+
+### 五、易混淆点辨析
+
+| 问题 | 答案 |
+|------|------|
+| 多处理机属于哪种？ | **MIMD**（B 卷选择题原题） |
+| GPU 属于哪种？ | **SIMD**（单指令多数据流） |
+| 哪种类型不存在？ | **MISD**（A 卷选择题原题） |
+| 向量处理器属于哪种？ | **SIMD** |
+| 并行度最高的类型？ | **MIMD** |
+
+> [!warning] 考试陷阱
+> 题目可能问"Flymn 分类法"（注意有些试卷会拼错为 Flymn），但指的都是 Flynn 分类法。另外要注意区分**多处理器**（multiprocessor，共享内存，MIMD）和**多计算机**（multicomputer，分布式内存，MIMD）——两者都属于 MIMD。
+
+## 关联笔记
+- [[计算机系统结构/复习文档/计算机系统结构基础与定量原理]]
+- [[小题10-并行计算机系统结构分类]]
+- [[大题1-CPU性能参数计算]]
@@ -0,0 +1,150 @@
+---
+tags:
+  - 计算机系统结构
+  - 重点复习
+  - 并行处理
+  - 多处理机
+create time: 2026-06-16 21:21
+---
+
+# 小题 10 — 并行计算机系统结构的分类
+
+## 概述
+
+本题考查并行计算机系统结构的两大类型：**集中式共享存储结构**（Centralized Shared-Memory）和**分布式存储器多处理机**（Distributed-Memory Multiprocessor）的特点、区别及代表架构。
+
+> [!tip] 考试重点
+> 重点掌握两种架构的**存储访问方式**、**可扩展性**和**典型代表**。SMP vs NUMA vs MPP vs Cluster 的对比是高频考点。
+
+## 正文
+
+### 一、并行计算机系统的基本分类
+
+按照**存储器的组织方式**和**处理器间的通信方式**，并行计算机系统可分为两大类：
+
+```mermaid
+graph TD
+    ROOT["Parallel Computer Systems"] --> CS["Centralized Shared Memory"]
+    ROOT --> DD["Distributed Memory"]
+
+    CS --> SMP["SMP: Symmetric Multiprocessor"]
+    CS --> NUMA["NUMA: Non-Uniform Memory Access"]
+
+    DD --> MPP["MPP: Massively Parallel Processor"]
+    DD --> Cluster["Cluster / MPP"]
+```
+
+### 二、集中式共享存储结构
+
+**核心特征**：所有处理器共享**一个统一的物理内存**，通过系统总线或交叉开关连接。
+
+#### 2.1 SMP（对称多处理器）
+
+| 特征 | 说明 |
+|------|------|
+| 存储视图 | 所有处理器看到**统一的地址空间**，访问任何内存单元的延迟**相同** |
+| 通信方式 | 通过 Load/Store 指令直接读写共享变量 |
+| 处理器数量 | 通常 **2~8 个**（受总线带宽限制） |
+| 一致性维护 | **监听协议**（Snooping Protocol），如 MSI、MESI |
+| 缓存一致性 | 硬件自动维护，程序员无感 |
+
+```mermaid
+graph TD
+    P1["CPU 1 + Cache"] --> BUS["System Bus"]
+    P2["CPU 2 + Cache"] --> BUS
+    P3["CPU 3 + Cache"] --> BUS
+    P4["CPU 4 + Cache"] --> BUS
+    BUS --> MEM["Shared Memory"]
+```
+
+#### 2.2 NUMA（非统一内存访问）
+
+| 特征 | 说明 |
+|------|------|
+| 存储视图 | 统一地址空间，但**本地内存访问快，远程内存访问慢** |
+| 通信方式 | 同样通过 Load/Store，但远程访问延迟更高 |
+| 处理器数量 | 可扩展到 **数十个** |
+| 一致性维护 | 目录协议（Directory Protocol）或增强型监听协议 |
+| 拓扑结构 | 每个处理器有**本地内存**，通过互连网络连接 |
+
+```mermaid
+graph LR
+    subgraph Node1["Node 1"]
+        CPU1["CPU"] --- LM1["Local Memory"]
+    end
+    subgraph Node2["Node 2"]
+        CPU2["CPU"] --- LM2["Local Memory"]
+    end
+    subgraph Node3["Node 3"]
+        CPU3["CPU"] --- LM3["Local Memory"]
+    end
+    Node1 <-->|"Interconnect"| Node2
+    Node2 <-->|"Interconnect"| Node3
+```
+
+> [!question] SMP 和 NUMA 都是共享内存，区别是什么？
+> SMP 中所有内存的访问延迟**完全相同**（Uniform），适合小规模系统。NUMA 中本地内存访问快、远程访问慢（Non-Uniform），适合更大规模系统。NUMA 是 SMP 的扩展——当处理器数量增加到总线无法承载时，就需要将内存分布到各处理器附近。
+
+### 三、分布式存储器多处理机
+
+**核心特征**：每个处理器有**独立的本地内存**，处理器之间通过**消息传递**（Message Passing）通信。
+
+#### 3.1 MPP（大规模并行处理器）
+
+| 特征 | 说明 |
+|------|------|
+| 存储视图 | 每个节点有**独立的地址空间** |
+| 通信方式 | 通过 **MPI** 等消息传递库发送/接收数据 |
+| 处理器数量 | **数千到数万** |
+| 一致性维护 | **无需**——程序员显式管理数据分布和一致性 |
+| 典型代表 | 超级计算机（如 Summit、Fugaku） |
+
+#### 3.2 Cluster（集群）
+
+| 特征 | 说明 |
+|------|------|
+| 存储视图 | 每个节点是独立的计算机，有独立的 OS |
+| 通信方式 | 通过**高速网络**（如 InfiniBand）和消息传递 |
+| 处理器数量 | **数千到数万** |
+| 一致性维护 | **无需**——完全由程序员管理 |
+| 典型代表 | Google 集群、HPC 集群 |
+
+### 四、两种架构的全面对比
+
+> [!abstract]- 答案
+>
+> | 对比维度 | 集中式共享存储 | 分布式存储器多处理机 |
+> |----------|:--------------:|:--------------------:|
+> | **存储视图** | 统一地址空间 | 独立地址空间 |
+> | **通信方式** | Load/Store（隐式） | 消息传递 MPI（显式） |
+> | **一致性** | 硬件维护（监听/目录协议） | 程序员管理 |
+> | **可扩展性** | 差（< 64 处理器） | 好（数千处理器） |
+> | **编程难度** | 低（共享变量编程） | 高（需显式通信） |
+> | **典型规模** | 2~64 处理器 | 数百~数万处理器 |
+> | **代表架构** | SMP、NUMA | MPP、Cluster |
+
+| 对比维度 | 集中式共享存储 | 分布式存储器多处理机 |
+|:--------:|:--------------:|:--------------------:|
+| 数据访问 | 透明——直接访问内存地址 | 非透明——需 Send/Receive |
+| 网络延迟 | 低（总线/交叉开关） | 高（需经过多级互连） |
+| 硬件成本 | 低~中 | 高（需高速互连网络） |
+| 适用场景 | 通用服务器、小型数据中心 | 超算、大规模数据分析 |
+
+### 五、设计权衡
+
+```mermaid
+graph TD
+    SCALABILITY["Scalability"] -->|"SMP/NUMA"| SHARED["Shared Memory: Easy to Program"]
+    SCALABILITY -->|"MPP/Cluster"| DISTRIBUTED["Distributed: Scales Better"]
+
+    SHARED --> SHARED_COST["Cost: Cache Coherence Hardware"]
+    DISTRIBUTED --> DIST_COST["Cost: Programmer Effort"]
+```
+
+> [!question] 未来的趋势是什么？
+> 现代超算普遍采用**混合架构**：节点内是 NUMA（共享内存），节点间是消息传递（分布式）。这样既利用了共享内存的编程便利性，又利用了分布式架构的可扩展性。
+
+## 关联笔记
+- [[计算机系统结构/复习文档/多处理器与并行处理]]
+- [[小题1-冯氏分类法与并行度]]
+- [[总线与IO系统]]
@@ -0,0 +1,137 @@
+---
+tags:
+  - 计算机系统结构
+  - 重点复习
+  - 流水线
+  - 分类
+create time: 2026-06-16 21:21
+---
+
+# 小题 2 — 流水线的分类
+
+## 概述
+
+本题考查流水线的多种分类维度：**单功能/多功能**、**静态/动态**、**线性/非线性** 的含义及区别。这是理解流水线技术的基础，常以选择题形式出现。
+
+> [!tip] 考试重点
+> 需理解每种分类的**定义**和**区别**，尤其是静态多功能与动态多功能的对比，以及线性与非线性流水线的本质差异（是否允许反馈连接）。
+
+## 正文
+
+### 一、按功能分类：单功能 vs 多功能
+
+| 分类 | 含义 | 特点 | 示例 |
+|------|------|------|------|
+| **单功能流水线** | 只能完成**一种**固定功能 | 设计简单、专用性强 | 浮点加法流水线、浮点乘法流水线 |
+| **多功能流水线** | 同一流水线可以完成**多种**不同功能 | 灵活性高、但控制复杂 | 可重构的 ALU 流水线 |
+
+> [!question] 思考：为什么需要多功能流水线？
+> 现代处理器需要执行加法、乘法、逻辑运算等多种操作。如果每种操作都设计一条专用流水线，硬件开销太大。多功能流水线通过**动态重构**段间连接，用同一条流水线支持多种功能，提高了硬件利用率。
+
+### 二、按工作方式分类：静态 vs 动态
+
+这是**针对多功能流水线**的进一步细分，描述的是流水线在同一时刻能否同时执行多种功能。
+
+| 分类 | 含义 | 同时执行多种功能？ | 控制复杂度 | 性能 |
+|------|------|:------------------:|:----------:|:----:|
+| **静态流水线** | 同一时刻只能按**一种**功能方式工作 | **否**——切换功能需要排空流水线 | 低 | 较低 |
+| **动态流水线** | 同一时刻可以有**多种**功能在不同段中同时工作 | **是**——不同段可以执行不同功能的子任务 | 高 | 较高 |
+
+```mermaid
+graph LR
+    subgraph Static["Static Pipeline"]
+        S1["Phase 1: All ADD"] --> S2["Phase 2: All MUL"]
+        S2 --> S3["Phase 3: All ADD"]
+    end
+    subgraph Dynamic["Dynamic Pipeline"]
+        D1["Segment 1: ADD task"] --> D2["Segment 2: MUL task"]
+        D2 --> D3["Segment 3: ADD task"]
+    end
+```
+
+> [!note] 静态 vs 动态的关键区别
+>
+> **静态流水线**的工作过程：
+> 1. 当前阶段全部执行功能 A 的任务
+> 2. 功能 A 的最后一个任务**完全流出**后（排空）
+> 3. 才能开始执行功能 B 的任务
+> 4. 不允许 A 和 B 的任务在流水线中同时存在
+>
+> **动态流水线**的工作过程：
+> 1. 功能 A 的某个任务在段 3 执行
+> 2. 同一时刻，功能 B 的另一个任务可以在段 1 开始
+> 3. 各段独立工作，无需排空
+>
+> 代价：动态流水线需要更复杂的**段间互连**和**冲突检测**逻辑，因为不同功能可能需要不同的段间数据通路。
+
+> [!question] 思考：静态流水线一定是单功能的吗？
+> 不一定。静态流水线可以是多功能的，只是在某一时刻只执行一种功能。例如一条既能做加法又能做乘法的流水线，在某段时间全部做加法，排空后全部做乘法——这是**静态多功能流水线**。
+
+### 三、按结构分类：线性 vs 非线性
+
+| 分类 | 含义 | 特点 | 调度难度 |
+|------|------|------|:--------:|
+| **线性流水线** | 各段**串行连接**，无反馈、无前馈 | 每拍可送入一个新任务 | 简单 |
+| **非线性流水线** | 各段之间存在**反馈**或**前馈**连接 | 不能每拍送入新任务，需要预约表调度 | 复杂 |
+
+```mermaid
+graph LR
+    subgraph Linear["Linear Pipeline"]
+        L1["S1"] --> L2["S2"] --> L3["S3"] --> L4["S4"]
+    end
+    subgraph NonLinear["Non-Linear Pipeline"]
+        NL1["S1"] --> NL2["S2"]
+        NL2 --> NL3["S3"]
+        NL3 --> NL4["S4"]
+        NL3 -.->|"Feedback"| NL1
+    end
+```
+
+> [!note] 线性 vs 非线性的本质区别
+>
+> **线性流水线**：数据单向流动，各段只使用一次。任务完成后立即释放所有段，下一拍可送入新任务。吞吐率恒定为 $1/\Delta t$（$\Delta t$ 为最长段时间）。
+>
+> **非线性流水线**：由于存在反馈连接，同一个任务可能**多次使用某一段**。如果新任务进入的间隔太小，就会产生**段冲突**——两个任务在同一时刻争用同一段。因此需要通过**预约表分析**来确定安全的进入间隔。
+>
+> 非线性流水线的调度是本课程的**核心难点**，详见 [[大题3-非线性流水线调度]]。
+
+### 四、分类体系总览
+
+```mermaid
+graph TD
+    ROOT["Pipeline Classification"] --> F["By Function"]
+    ROOT --> W["By Working Mode"]
+    ROOT --> S["By Structure"]
+
+    F --> F1["Single-Function"]
+    F --> F2["Multi-Function"]
+
+    W --> W1["Static"]
+    W --> W2["Dynamic"]
+
+    S --> S1["Linear"]
+    S --> S2["Non-Linear"]
+
+    F2 --> W
+```
+
+完整的分类组合关系：
+
+| 组合类型 | 含义 | 实例 |
+|----------|------|------|
+| 单功能线性 | 只做一种功能，段间串行 | 浮点加法流水线 |
+| 单功能非线性 | 只做一种功能，有反馈连接 | 某些迭代计算流水线 |
+| 多功能静态线性 | 多种功能但需排空后切换，无反馈 | 早期向量处理器 |
+| 多功能静态非线性 | 多种功能需排空切换，有反馈 | 复杂运算单元 |
+| 多功能动态线性 | 同时执行多种功能，无反馈 | 高端处理器的执行单元 |
+| 多功能动态非线性 | 同时执行多种功能，有反馈 | 最复杂的情况 |
+
+> [!warning] 考试常见陷阱
+> - "静态"和"线性"是两个**独立的维度**，不要混淆。静态/动态描述的是多功能流水线的工作方式；线性/非线性描述的是段间连接结构。
+> - 单功能流水线**无所谓**静态/动态（因为它只有一种功能，不存在"切换"的问题）。
+> - 线性流水线的调度是确定性的（每 $\Delta t$ 送入一个任务），非线性流水线需要专门的调度算法。
+
+## 关联笔记
+- [[计算机系统结构/复习文档/流水线技术]]
+- [[大题3-非线性流水线调度]]
+- [[小题3-控制冲突的解决措施]]
@@ -0,0 +1,151 @@
+---
+tags:
+  - 计算机系统结构
+  - 重点复习
+  - 流水线
+  - 控制冲突
+create time: 2026-06-16 21:21
+---
+
+# 小题 3 — 控制冲突的解决措施
+
+## 概述
+
+本题考查流水线中**控制冲突**（Control Hazard）的概念，以及为**减少分支指令引起的延迟**所采取的有效措施。控制冲突是流水线三大冲突之一，理解其解决方案对理解现代处理器设计至关重要。
+
+> [!tip] 考试重点
+> 重点掌握三大类解决措施：**暂停**、**预测**、**延迟分支**。其中延迟分支的"延迟槽"概念和分支预测的基本原理是常考知识点。
+
+## 正文
+
+### 一、什么是控制冲突？
+
+**控制冲突**（Control Hazard）是由**分支指令**（如 if-else、循环跳转）引起的。当处理器执行分支指令时，需要等到分支结果确定后才能知道下一条应该取哪里的指令。但在等待期间，流水线已经预取了后续指令——如果预测错误，这些预取的指令就必须作废。
+
+```mermaid
+graph LR
+    A["Branch Instruction"] --> B{"Branch Taken?"}
+    B -- "Yes" --> C["Target Address"]
+    B -- "No" --> D["PC + 4 (Next)"]
+
+    style B fill:#ff9800
+```
+
+> [!question] 控制冲突的代价有多大？
+> 假设分支指令在 EX 段（第 3 段）确定结果，那么在 5 段流水线中，分支指令后面有 2 条指令已经被取入流水线。如果分支跳转了，这 2 条指令就要作废——浪费 2 个时钟周期。对于深度流水线（如 15~20 段），分支延迟更大。
+
+### 二、解决措施总览
+
+| 措施 | 原理 | 性能收益 | 硬件开销 |
+|------|------|:--------:|:--------:|
+| **暂停（Stall）** | 等待分支结果确定后再取指 | 无（性能最差） | 无 |
+| **预测（Predict）** | 猜测分支方向，提前取指 | 高（预测准确时） | 中~高 |
+| **延迟分支（Delayed Branch）** | 分支指令后的延迟槽总被执行 | 中等 | 低 |
+
+### 三、措施详解
+
+#### 3.1 暂停（Stall）
+
+最简单的方法：分支指令进入流水线后，**暂停**后续指令的取指，直到分支结果确定。
+
+- **优点**：实现最简单，零硬件开销
+- **缺点**：性能损失严重。对于 $k$ 段流水线，分支在第 $m$ 段确定结果时，浪费 $m-1$ 个时钟周期
+
+> [!warning] 为什么暂停不可接受？
+> 分支指令在程序中占比约 15%~25%。如果每条分支指令都暂停 2~3 拍，流水线效率将下降 30%~75%。这就是为什么必须采用预测技术。
+
+#### 3.2 分支预测（Branch Prediction）
+
+在分支结果确定之前，**预测**分支方向并提前取指。预测分为两大类：
+
+| 预测类型 | 方法 | 预测准确率 | 硬件复杂度 |
+|----------|------|:----------:|:----------:|
+| **静态预测** | 编译时确定，运行时不变 | 60%~70% | 低 |
+| **动态预测** | 运行时根据历史信息动态调整 | 90%~95% | 高 |
+
+**静态预测的常见策略**：
+
+| 策略 | 预测行为 | 适用场景 |
+|------|----------|----------|
+| 总是预测不跳转 | 分支不发生，继续顺序取指 | 循环体外的分支 |
+| 总是预测跳转 | 分支发生，跳转到目标地址 | 循环体内的分支（循环通常继续） |
+| 根据分支方向预测 | 向后跳转预测为跳转（循环），向前跳转预测为不跳转 | 通用场景 |
+| 由编译器标注 | 编译器在分支指令中设置预测位 | Profile-guided 优化 |
+
+**动态预测的常见策略**：
+
+| 策略 | 原理 | 状态数 |
+|------|------|:------:|
+| 1 位预测器 | 记录上次分支结果 | 2 |
+| 2 位饱和计数器 | 需要连续 2 次预测错误才改变方向 | 4 |
+| 相关预测器 | 参考其他分支的历史 | 4+ |
+| 锦标赛预测器 | 多个预测器投票 | 多 |
+
+```mermaid
+stateDiagram-v2
+    [*] --> StronglyNotTaken
+    StronglyNotTaken --> WeaklyNotTaken: "Taken"
+    WeaklyNotTaken --> WeaklyTaken: "Taken"
+    WeaklyTaken --> StronglyTaken: "Taken"
+    StronglyTaken --> WeaklyTaken: "Not Taken"
+    WeaklyTaken --> WeaklyNotTaken: "Not Taken"
+    WeaklyNotTaken --> StronglyNotTaken: "Not Taken"
+```
+
+> [!note] 2 位饱和计数器的工作原理
+> 2 位饱和计数器是最经典的动态预测方案：
+> - **4 个状态**：强不跳转(00)、弱不跳转(01)、弱跳转(10)、强跳转(11)
+> - **预测规则**：高位为 1 预测跳转，高位为 0 预测不跳转
+> - **更新规则**：分支跳转时计数器+1（饱和），不跳转时-1（饱和）
+> - **优势**：偶发的方向改变不会立即改变预测（需要连续 2 次才翻转），适合循环场景
+
+#### 3.3 延迟分支（Delayed Branch）
+
+**核心思想**：编译器将分支指令后面的一条指令定义为**延迟槽**（Delay Slot），延迟槽中的指令**无论分支是否跳转都会被执行**。
+
+```
+BEQ  R1, R2, TARGET   ; 分支指令
+ADD  R3, R4, R5       ; 延迟槽：总被执行
+SUB  R6, R7, R8       ; 分支目标（如果跳转）
+```
+
+编译器的任务是找到一条**安全的、有用的**指令填入延迟槽：
+
+| 填充策略 | 方法 | 效果 |
+|----------|------|------|
+| 从前调度 | 将分支指令**前面**的独立指令移入延迟槽 | 最常用 |
+| 从目标调度 | 将分支目标处的指令复制到延迟槽 | 适用于循环 |
+| 从失败路径调度 | 将分支不跳转时的下一条指令移入延迟槽 | 适用于 if-else |
+| 填充 NOP | 找不到合适指令时填空操作 | 无收益但保证正确性 |
+
+> [!question] 思考：延迟分支有什么局限？
+> 1. 只能补偿**1 拍**的分支延迟（延迟槽只有 1 条指令的空间）
+> 2. 对于深度流水线（延迟 2~3 拍），延迟分支**力不从心**
+> 3. 需要编译器配合，增加了编译器设计的复杂度
+>
+> 因此现代深度流水线处理器主要依靠**动态分支预测**，延迟分支主要用于简单 RISC 处理器。
+
+### 四、三种措施的对比
+
+| 对比维度 | 暂停 | 分支预测 | 延迟分支 |
+|----------|:----:|:--------:|:--------:|
+| 性能 | 最差 | 最好 | 中等 |
+| 硬件开销 | 无 | 中~高 | 低 |
+| 需要编译器支持 | 否 | 否 | 是 |
+| 适用流水线深度 | 浅 | 深/浅均可 | 浅（1~2 拍延迟） |
+| 预测错误时的处理 | 不需要 | 需要冲刷流水线 | 不需要 |
+| 现代处理器使用 | 仅作后备 | **主要手段** | 辅助手段 |
+
+> [!abstract]- 答案
+> 为减少分支指令引起的控制冲突延迟，采取的有效措施包括：
+>
+> **（1）暂停**：等待分支结果确定后再取指，简单但性能最差。
+>
+> **（2）分支预测**：静态预测（预测不跳转/预测跳转）和动态预测（1 位/2 位饱和计数器、相关预测器）。
+>
+> **（3）延迟分支**：编译器在分支指令后的延迟槽中填入必定执行的指令。
+
+## 关联笔记
+- [[计算机系统结构/复习文档/流水线技术]]
+- [[小题2-流水线的分类]]
+- [[小题4-流水寄存器的作用]]
@@ -0,0 +1,109 @@
+---
+tags:
+  - 计算机系统结构
+  - 重点复习
+  - 流水线
+  - 流水寄存器
+create time: 2026-06-16 21:21
+---
+
+# 小题 4 — 流水寄存器的作用
+
+## 概述
+
+本题考查**流水寄存器**（Pipeline Register / 段间寄存器）在流水线中的核心作用。流水寄存器是流水线各段之间的**缓冲与隔离**机构，是流水线能够正确工作的关键硬件基础。
+
+> [!tip] 考试重点
+> 理解流水寄存器的三大核心作用：**缓冲数据**、**隔离各段**、**同步传输**。这道题常以简答题或填空题出现，回答时要结合流水线的时空图说明。
+
+## 正文
+
+### 一、什么是流水寄存器？
+
+在流水线中，每个功能段之间都有一组**寄存器**，称为**流水寄存器**（也叫**段间寄存器**或**锁存器**）。它们在每个时钟周期的末尾将当前段的输出锁存，作为下一段在下一时钟周期的输入。
+
+```mermaid
+graph LR
+    IF["IF: Instruction Fetch"] --> R1["Pipeline Register"]
+    R1 --> ID["ID: Instruction Decode"]
+    R2["Pipeline Register"] --> EX["EX: Execute"]
+    EX --> R3["Pipeline Register"]
+    R3 --> MEM["MEM: Memory Access"]
+    MEM --> R4["Pipeline Register"]
+    R4 --> WB["WB: Write Back"]
+
+    style R1 fill:#e3f2fd
+    style R2 fill:#e3f2fd
+    style R3 fill:#e3f2fd
+    style R4 fill:#e3f2fd
+```
+
+### 二、流水寄存器的核心作用
+
+> [!abstract]- 答案
+> 流水寄存器的三大作用：
+>
+> **（1）缓冲数据**：暂存当前段的输出结果，为下一段提供稳定的输入。
+>
+> **（2）隔离各段**：将相邻两段在时间上和空间上隔离，使各段可以**同时处理不同任务的不同阶段**。
+>
+> **（3）同步传输**：在时钟边沿统一更新，确保所有段在同一时刻切换到下一个状态。
+
+> [!note] 详细解释
+>
+> **作用一：缓冲数据**
+>
+> 流水寄存器保存当前段产生的**所有中间结果**，包括：
+> - 指令本身（操作码、地址码）
+> - 运算结果（ALU 输出、内存读取的数据）
+> - 控制信号（写使能、寄存器编号等）
+>
+> 这些数据在时钟边沿被锁存，下一个时钟周期供下一段使用。没有流水寄存器，前一段的输出在组合逻辑稳定前可能会被下一段错误读取。
+>
+> **作用二：隔离各段**
+>
+> 这是流水寄存器最关键的作用。它实现了**时间上的隔离**：
+> - 在时钟周期 T1，段 1 处理任务 A，段 2 处理任务 B
+> - 任务 A 的中间结果存在流水寄存器中
+> - 在时钟周期 T2，段 1 处理新任务 C，段 2 从流水寄存器读取任务 A 的数据继续处理
+>
+> 没有这种隔离，各段就不能**重叠执行**不同任务——流水线退化为串行执行。
+>
+> **作用三：同步传输**
+>
+> 流水寄存器由**统一的时钟信号**控制，在每个时钟上升沿同时更新。这保证了：
+> - 所有段在同一时刻切换状态
+> - 数据不会因为各段完成时间不同而产生竞争冒险
+> - 流水线的推进是**节拍式**的，一个时钟周期推进一拍
+
+### 三、流水寄存器中存储的内容
+
+一组典型的流水寄存器（以 IF/ID 之间为例）需要存储：
+
+| 信息类别 | 具体内容 | 用途 |
+|----------|----------|------|
+| 指令信息 | 指令字（32 位） | 供 ID 段译码 |
+| PC 值 | 当前指令地址 | 用于分支计算和调试 |
+| 控制信号 | ALUOp、MemRead、RegWrite 等 | 供后续段使用 |
+| 立即数 | 符号扩展后的立即数 | 供 EX 段计算 |
+
+> [!question] 流水寄存器的宽度由什么决定？
+> 由**需要传递的信息总量**决定。例如 IF/ID 寄存器需要存储 32 位指令 + 32 位 PC + 若干控制位 ≈ 80 位。EX/MEM 寄存器需要存储 ALU 结果 + 写回数据 + 目标寄存器号 + 控制位等。流水寄存器的宽度直接影响芯片面积和功耗。
+
+### 四、没有流水寄存器会怎样？
+
+假设去掉所有流水寄存器，5 个功能段直接级联：
+
+| 情况 | 结果 |
+|------|------|
+| 各段延迟不同 | 快段等慢段，整体以最慢段的速度运行 |
+| 不同任务重叠 | **数据冲突**——前一段的输出还在变化中就被后一段读取 |
+| 时钟偏移 | 不同段的信号到达时间不同，可能导致逻辑错误 |
+
+> [!important] 结论
+> 流水寄存器是流水线能够**并行处理多个任务**的**硬件基础**。没有流水寄存器，就无法实现"各段同时处理不同任务"的重叠执行模式，流水线退化为延迟更长的串行执行。
+
+## 关联笔记
+- [[计算机系统结构/复习文档/流水线技术]]
+- [[小题2-流水线的分类]]
+- [[小题3-控制冲突的解决措施]]
@@ -0,0 +1,135 @@
+---
+tags:
+  - 计算机系统结构
+  - 重点复习
+  - 指令级并行
+  - ILP
+create time: 2026-06-16 21:21
+---
+
+# 小题 5 — 指令级并发的开发方法
+
+## 概述
+
+本题考查**指令级并行**（Instruction-Level Parallelism, ILP）的开发方法，包括**静态方法**（编译器主导）和**动态方法**（硬件主导）两大类。ILP 是提升单处理器性能的核心技术途径。
+
+> [!tip] 考试重点
+> 了解有哪些主要的 ILP 开发方法即可，重点区分"静态"和"动态"的分类及代表技术。不需要深入每种方法的实现细节。
+
+## 正文
+
+### 一、什么是指令级并行（ILP）？
+
+**指令级并行**是指程序中多条指令**同时执行或重叠执行**的可能性。ILP 的开发目标是在不改变程序语义的前提下，尽可能让更多的指令在同一时刻处于执行状态。
+
+> [!question] ILP 的理论基础是什么？
+> 程序中大部分指令之间**没有**数据依赖或控制依赖。研究表明，一个典型程序中每条指令平均只有 0.5~1.5 条真依赖。这意味着在理论上，一个程序可以同时执行 3~5 条指令——但需要硬件或编译器来发现和利用这种并行性。
+
+### 二、开发方法总览
+
+```mermaid
+graph TD
+    ROOT["ILP Development"] --> S["Static Methods"]
+    ROOT --> D["Dynamic Methods"]
+
+    S --> S1["Loop Unrolling"]
+    S --> S2["Software Pipelining"]
+    S --> S3["Trace Scheduling"]
+    S --> S4["Instruction Scheduling"]
+
+    D --> D1["Superscalar"]
+    D --> D2["Out-of-Order Execution"]
+    D --> D3["Speculative Execution"]
+    D --> D4["Register Renaming"]
+    D --> D5["Branch Prediction"]
+    D --> D6["Dynamic Scheduling"]
+```
+
+### 三、静态方法（编译器主导）
+
+静态方法在**编译时**分析和优化指令顺序，运行时按优化后的顺序执行。
+
+| 方法 | 原理 | 效果 |
+|------|------|------|
+| **循环展开**（Loop Unrolling） | 将循环体复制多份，减少循环控制指令的开销 | 减少分支指令占比，增加调度空间 |
+| **软件流水**（Software Pipelining） | 从不同迭代中抽取指令组成新的循环体 | 使每次迭代中各段重叠执行 |
+| **轨迹调度**（Trace Scheduling） | 选择最可能执行的路径（trace），在该路径上全局优化 | 对热路径的优化效果显著 |
+| **指令调度**（Instruction Scheduling） | 重排指令顺序以避免数据冲突和结构冲突 | 减少 Stall，提高流水线利用率 |
+
+> [!note] 循环展开示例
+>
+> **原始代码**（4 次迭代）：
+> ```
+> for (i = 0; i < 4; i++)
+>     C[i] = A[i] + B[i];
+> ```
+>
+> **循环展开 2 次**：
+> ```
+> C[0] = A[0] + B[0];
+> C[1] = A[1] + B[1];   // 与上一条无依赖，可并行
+> C[2] = A[2] + B[2];
+> C[3] = A[3] + B[3];   // 与上一条无依赖，可并行
+> ```
+>
+> 展开后分支指令从 4 条减为 0 条（或 1 条），且相邻指令的独立性更高，编译器有更多调度自由度。
+
+> [!question] 静态方法的局限性？
+> 1. 编译时无法知道**运行时信息**（如 Cache 是否命中、分支方向），调度可能不是最优的
+> 2. 不同的输入数据可能改变最优的指令顺序
+> 3. 编译器必须保守处理——如果不确定两条指令是否相关，就假定相关，不做并行化
+
+### 四、动态方法（硬件主导）
+
+动态方法在**运行时**由处理器硬件发现和利用 ILP。
+
+| 方法 | 原理 | 效果 |
+|------|------|------|
+| **超标量**（Superscalar） | 每个时钟周期发射**多条指令**到多个功能部件 | 基础并行执行能力 |
+| **乱序执行**（Out-of-Order Execution） | 指令不按程序顺序执行，就绪即可执行 | 消除等待，提高利用率 |
+| **推测执行**（Speculative Execution） | 在分支结果确定前就执行分支目标处的指令 | 隐藏分支延迟 |
+| **寄存器重命名**（Register Renaming） | 将逻辑寄存器映射到物理寄存器，消除名相关 | 消除 WAR 和 WAW 冲突 |
+| **分支预测**（Branch Prediction） | 预测分支方向，提前取指和执行 | 减少控制冲突 |
+| **动态调度**（Dynamic Scheduling） | 如 Tomasulo 算法，硬件动态分配资源和调度指令 | 处理数据相关的等待 |
+
+```mermaid
+graph LR
+    subgraph InOrder["In-Order Issue"]
+        I1["Instruction 1"] --> I2["Instruction 2"] --> I3["Instruction 3"]
+    end
+    subgraph OutOfOrder["Out-of-Order Execution"]
+        O1["Instruction 1"] --> O_EX1["Execute"]
+        O2["Instruction 2"] -->|"Stall (waiting)"| O2_W["Wait"]
+        O3["Instruction 3"] -->|"Ready first"| O_EX3["Execute"]
+    end
+```
+
+> [!note] Tomasulo 算法简介
+> Tomasulo 算法是 IBM 在 1967 年为 System/360/91 开发的动态调度算法，核心思想：
+> 1. **保留站**（Reservation Station）：每个功能部件有若干保留站，存放等待执行的指令及其操作数
+> 2. **公共数据总线**（CDB）：运算结果通过 CDB 广播，所有等待该结果的保留站同时获取
+> 3. **寄存器重命名**：通过保留站标签替代寄存器号，自动消除 WAR 和 WAW 冲突
+>
+> Tomasulo 算法是现代超标量处理器乱序执行引擎的理论基础。
+
+### 五、静态 vs 动态方法对比
+
+| 对比维度 | 静态方法 | 动态方法 |
+|----------|----------|----------|
+| 决策时机 | 编译时 | 运行时 |
+| 信息来源 | 程序结构分析 | 实际运行状态 |
+| 适应性 | 差（无法适应运行时变化） | 好（根据实际情况调整） |
+| 硬件开销 | 低 | 高 |
+| 典型代表 | 循环展开、指令调度 | 超标量、乱序执行 |
+| 适用场景 | 嵌入式、低功耗处理器 | 高性能通用处理器 |
+
+> [!question] 现代处理器如何组合使用？
+> 现代处理器（如 Intel Core、ARM Cortex-A）**同时使用**静态和动态方法：
+> - 编译器做指令调度和循环展开（静态）
+> - 硬件做超标量发射、乱序执行和分支预测（动态）
+> - 两者互补：编译器提供良好的初始顺序，硬件进一步挖掘运行时并行性
+
+## 关联笔记
+- [[计算机系统结构/复习文档/流水线技术]]
+- [[小题3-控制冲突的解决措施]]
+- [[小题2-流水线的分类]]
@@ -0,0 +1,145 @@
+---
+tags:
+  - 计算机系统结构
+  - 重点复习
+  - Cache
+  - 组相联
+  - 标识存储器
+create time: 2026-06-16 21:21
+---
+
+# 小题 6 — 组相联映射与标识存储器
+
+## 概述
+
+本题考查**组相联映射方式**下标识存储器（Tag Memory）的两种实现方法——**相联存储器**（Content-Addressable Memory, CAM）和**单体多字存储器**，以及所需的**比较器个数**。这是理解 Cache 硬件实现的关键知识点。
+
+> [!tip] 考试重点
+> 重点掌握组相联映射中两种标识存储器实现方案的比较器个数计算。相联存储器方案用 $n$ 个比较器（$n$ 为相联度），单体多字存储器方案用 1 个比较器但需要多体并行读取。
+
+## 正文
+
+### 一、组相联映射回顾
+
+$n$ 路组相联（$n$-way Set Associative）是直接映像和全相联的折中：
+
+| 特征 | 直接映像 | $n$ 路组相联 | 全相联 |
+|:----:|:--------:|:----------:|:------:|
+| 映射关系 | 一块对一行 | 一块对一组（组内 $n$ 行） | 一块对任意行 |
+| 查找范围 | 1 个位置 | $n$ 个位置 | 所有位置 |
+| 比较次数 | 1 | $n$ | 全部行数 |
+
+> [!question] 为什么组相联需要标识存储器？
+> 组相联映射中，一个主存块可以映射到一组内的**任意一行**。处理器发出的地址需要与该组内**所有行的 Tag**进行比较，才能确定是否命中。存储这些 Tag 并进行比较的硬件就是**标识存储器**。
+
+### 二、标识存储器的两种实现方法
+
+#### 2.1 方法一：相联存储器（CAM）
+
+**相联存储器**是一种特殊的存储器，它不是通过地址访问，而是通过**内容匹配**来查找。每个存储单元都内置了一个比较器。
+
+```mermaid
+graph LR
+    subgraph CAM["CAM Implementation"]
+        T1["Tag Entry 1"] --> C1["Comparator 1"]
+        T2["Tag Entry 2"] --> C2["Comparator 2"]
+        T3["Tag Entry 3"] --> C3["Comparator 3"]
+        T4["Tag Entry n"] --> C4["Comparator n"]
+    end
+    ADDR["Input Tag"] --> C1
+    ADDR --> C2
+    ADDR --> C3
+    ADDR --> C4
+    C1 --> M["Match Logic"]
+    C2 --> M
+    C3 --> M
+    C4 --> M
+```
+
+| 项目 | 说明 |
+|------|------|
+| 存储结构 | 每个 Tag 条目自带比较器，**并行比较** |
+| 比较器个数 | $n$ 个（$n$ = 相联度/路数） |
+| 速度 | **快**——所有路同时比较，一个时钟周期完成 |
+| 硬件开销 | **大**——每个条目都需要一个比较器 |
+
+> [!example] 示例：4 路组相联的 CAM 实现
+>
+> 每组有 4 个 Tag 条目，每个条目配一个比较器：
+>
+> | 组内行号 | Tag 存储 | 比较器 | 输出 |
+> |:--------:|:--------:|:------:|:----:|
+> | 行 0 | Tag₀ | CMP₀ | Hit₀ |
+> | 行 1 | Tag₁ | CMP₁ | Hit₁ |
+> | 行 2 | Tag₂ | CMP₂ | Hit₂ |
+> | 行 3 | Tag₃ | CMP₃ | Hit₃ |
+>
+> **比较器个数 = 4 个**（每个时钟周期 4 路同时比较）
+
+#### 2.2 方法二：单体多字存储器
+
+将一组内所有行的 Tag 存在一个**单体多字存储器**中。每次读出该组所有行的 Tag，再用**一个比较器**逐个比较（或用一个多位比较器一次比较）。
+
+```mermaid
+graph LR
+    SET["Set Index"] --> MEM["Multi-Word Memory"]
+    MEM --> T["All n Tags in the Set"]
+    T --> CMP["1 Comparator (or sequential)"]
+    ADDR["Input Tag"] --> CMP
+    CMP --> HIT["Hit Signal"]
+```
+
+| 项目 | 说明 |
+|------|------|
+| 存储结构 | 一个存储器存所有 Tag，一次读出一组的所有 Tag |
+| 比较器个数 | **1 个**（但位宽较大，需比较 Tag 的全部位） |
+| 速度 | **较慢**——需要先读出再比较，可能需要多拍 |
+| 硬件开销 | **小**——只需 1 个比较器 |
+
+> [!question] 单体多字存储器方案真的只用 1 个比较器吗？
+> 严格来说，如果要用**一拍**完成比较，需要用 $n$ 个比较器（读出 $n$ 个 Tag 同时比较）。如果允许**多拍**完成，可以只用 1 个比较器逐个比较。实际设计中通常在面积和速度之间折中。考试中需要根据题意判断。
+
+### 三、两种方案的比较器个数总结
+
+> [!abstract]- 答案
+>
+> | 实现方案 | 比较器个数 | 速度 | 硬件开销 |
+> |----------|:----------:|:----:|:--------:|
+> | **相联存储器（CAM）** | $n$ 个（$n$ = 相联度） | 快（并行比较） | 大 |
+> | **单体多字存储器** | 1 个（逐个比较）或 $n$ 个（并行比较） | 较慢 | 小 |
+
+> [!note] 关键计算
+>
+> **$n$ 路组相联**标识存储器实现方案对比：
+>
+> | 参数 | CAM 方案 | 单体多字方案 |
+> |:----:|:--------:|:----------:|
+> | 存储器数量 | $n$ 个独立存储体 | 1 个多字存储体 |
+> | 每个存储体宽度 | Tag 位宽 | $n \times$ Tag 位宽 |
+> | 比较器个数 | **$n$ 个** | **1 个**（串行）或 **$n$ 个**（并行） |
+> | 比较延迟 | 1 拍 | 1 拍（并行）或 $n$ 拍（串行） |
+> | 适用场景 | 高速 L1 Cache | 面积受限的场景 |
+
+### 四、数值化示例
+
+> [!example] 完整示例
+>
+> **已知**：32 位地址，Cache 容量 16KB，块大小 64B，4 路组相联。
+>
+> - Offset = $\log_2(64) = 6$ 位
+> - 组数 = $(16\text{KB} / 64\text{B}) / 4 = 64$ 组
+> - Set Index = $\log_2(64) = 6$ 位
+> - Tag = $32 - 6 - 6 = 20$ 位
+>
+> | 方案 | 存储器数量 | 每个体位宽 | 比较器个数 | 比较器位宽 |
+> |:----:|:----------:|:----------:|:----------:|:----------:|
+> | CAM | 4 | 20 位 | **4** | 20 位 |
+> | 单体多字 | 1 | 80 位（4×20） | **1** | 20 位 |
+
+> [!warning] 考试注意
+> 题目问"比较器个数"时要明确是哪种方案。如果是 CAM 方案，答案是**相联度 $n$**；如果是单体多字方案串行比较，答案是 **1**。考试中如果题目没明确说明方案，通常默认是 **CAM 方案**（因为这是 Cache 最常用的高速实现）。
+
+## 关联笔记
+- [[计算机系统结构/复习文档/存储系统与Cache]]
+- [[小题7-Cache不命中与3C模型]]
+- [[大题4-Cache性能计算]]
@@ -0,0 +1,145 @@
+---
+tags:
+  - 计算机系统结构
+  - 重点复习
+  - Cache
+  - 3C模型
+create time: 2026-06-16 21:21
+---
+
+# 小题 7 — Cache 不命中与 3C 模型
+
+## 概述
+
+本题考查 Cache 不命中的 **3C 分类模型**（Compulsory、Capacity、Conflict）及其各自的特点和对策。3C 模型是理解 Cache 行为和指导 Cache 优化的核心分析框架。
+
+> [!tip] 考试重点
+> 需要熟记三种不命中的名称、英文、原因和解决方法。考试常以选择题或简答题出现，题目可能给出一个场景让你判断属于哪种不命中类型。
+
+## 正文
+
+### 一、3C 模型概述
+
+Cache 不命中可以按**产生原因**分为三类，合称 **3C 模型**：
+
+```mermaid
+graph TD
+    ROOT["Cache Miss"] --> C1["Compulsory Miss"]
+    ROOT --> C2["Capacity Miss"]
+    ROOT --> C3["Conflict Miss"]
+
+    C1 --> C1R["First Access"]
+    C2 --> C2R["Cache Too Small"]
+    C3 --> C3R["Mapping Conflict"]
+```
+
+### 二、三种不命中详解
+
+| 类型 | 英文名 | 原因 | 发生条件 | 解决方法 |
+|:----:|--------|------|----------|----------|
+| **强制性不命中** | Compulsory Miss (Cold Miss) | **首次访问**某数据块 | Cache 冷启动时 | 增大块大小、硬件预取 |
+| **容量不命中** | Capacity Miss | Cache **容量不足** | 工作集超过 Cache 容量 | 增大 Cache 容量 |
+| **冲突不命中** | Conflict Miss | 多个块**映射到同一位置** | 直接映像或组相联中冲突 | 提高相联度、Victim Cache |
+
+#### 2.1 强制性不命中（Compulsory Miss）
+
+**原因**：某个数据块**第一次**被访问时，Cache 中必然没有该块。
+
+> [!note] 特点
+> - 也叫**冷启动不命中**（Cold Miss）或**首次访问不命中**
+> - 与 Cache 的容量和相联度**无关**——即使 Cache 无限大、全相联，第一次访问仍然不命中
+> - 在程序执行过程中只发生**一次**（对每个数据块）
+> - 在长时间运行的程序中，强制性不命中占总不命中的比例**很小**
+
+**对策**：
+
+| 方法 | 原理 |
+|------|------|
+| 增大块大小 | 一次调入更多相邻数据，减少后续访问的强制性不命中 |
+| 硬件预取 | 在数据被需要之前就将其调入 Cache |
+| 编译器预取 | 编译器插入预取指令，提前加载数据 |
+
+#### 2.2 容量不命中（Capacity Miss）
+
+**原因**：程序的**工作集**（频繁访问的数据集合）超过了 Cache 的总容量，导致刚被替换出的块很快又需要被访问。
+
+> [!note] 特点
+> - 与映射方式**无关**——即使是全相联 Cache，只要容量不够就会发生
+> - 在程序执行过程中**持续发生**
+> - 增大 Cache 容量可以直接减少容量不命中
+
+**对策**：
+
+| 方法 | 原理 |
+|------|------|
+| 增大 Cache 容量 | 直接扩大 Cache 以容纳更多工作集 |
+| 编译器优化 | 优化数据访问模式，减少工作集大小（如分块算法） |
+
+#### 2.3 冲突不命中（Conflict Miss）
+
+**原因**：在直接映像或组相联 Cache 中，多个主存块竞争同一个 Cache 行/组位置，相互替换。
+
+> [!note] 特点
+> - **只有直接映像和组相联 Cache 才有**——全相联 Cache 没有冲突不命中
+> - 即使 Cache 总容量足够，如果两个频繁访问的块映射到同一位置，也会反复冲突
+> - 典型场景：地址 A 映射到行 X，地址 B 也映射到行 X，交替访问 A 和 B 导致颠簸
+
+**对策**：
+
+| 方法 | 原理 |
+|------|------|
+| 提高相联度 | 更多路意味着更多位置，减少冲突概率 |
+| Victim Cache | 用小的全相联 Cache 保存最近被替换出的块 |
+| 伪相联 Cache | 先查主位置，不命中时再查次位置 |
+
+### 三、3C 模型对比表
+
+| 维度 | 强制性 | 容量 | 冲突 |
+|:----:|:------:|:----:|:----:|
+| **英文** | Compulsory | Capacity | Conflict |
+| **别名** | Cold Miss | - | Collision Miss |
+| **发生时机** | 首次访问 | 工作集过大 | 映射冲突 |
+| **全相联 Cache 中** | 有 | 有 | **无** |
+| **直接映像 Cache 中** | 有 | 有 | 有 |
+| **增大 Cache 容量** | 不影响 | **减少** | 减少 |
+| **提高相联度** | 不影响 | 不影响 | **减少** |
+| **增大块大小** | **减少** | 可能增加 | 可能增加 |
+
+> [!question] 思考：三种不命中的优先级？
+> 在优化 Cache 时，通常按以下优先级处理：
+> 1. **先减少冲突不命中**——成本最低（提高相联度或加 Victim Cache）
+> 2. **再减少容量不命中**——成本较高（增大 Cache 容量）
+> 3. **最后减少强制性不命中**——通常占比最小，预取技术有一定开销
+
+### 四、3C 模型的实验验证
+
+> [!example] 判断不命中类型
+>
+> **场景**：直接映像 Cache，4 行，块大小 16B。访问序列：0, 16, 0, 16, 0, 16, ...
+>
+> - 地址 0 → 行 0（**强制性不命中**，首次访问）
+> - 地址 16 → 行 1（**强制性不命中**，首次访问）
+> - 地址 0 → 行 0（**命中**，还在 Cache 中）
+> - 地址 16 → 行 1（**命中**）
+>
+> 现在改为：Cache 只有 **1 行**（直接映像），同样的访问序列：
+> - 地址 0 → 行 0（**强制性不命中**）
+> - 地址 16 → 行 0（**容量不命中** + **冲突不命中**——只有 1 行，0 被替换）
+> - 地址 0 → 行 0（**冲突不命中**——16 又被替换）
+> - ...
+>
+> 如果是 **全相联** 1 行 Cache：第一次是强制性不命中，第二次是**容量不命中**（全相联无冲突不命中）。
+
+> [!abstract]- 答案
+> Cache 不命中的 3C 模型：
+>
+> | 类型 | 原因 | 解决方法 |
+> |------|------|----------|
+> | **强制性**（Compulsory） | 首次访问 | 增大块大小、预取 |
+> | **容量**（Capacity） | Cache 太小 | 增大 Cache 容量 |
+> | **冲突**（Conflict） | 映射冲突 | 提高相联度、Victim Cache |
+
+## 关联笔记
+- [[计算机系统结构/复习文档/存储系统与Cache]]
+- [[小题6-组相联映射与标识存储器]]
+- [[大题4-Cache性能计算]]
@@ -0,0 +1,116 @@
+---
+tags:
+  - 计算机系统结构
+  - 重点复习
+  - IO系统
+  - 性能评价
+create time: 2026-06-16 21:21
+---
+
+# 小题 8 — I/O 系统性能评价参数
+
+## 概述
+
+本题考查评价 **I/O 系统性能**的主要参数。I/O 系统是连接处理器与外部世界的桥梁，其性能直接影响整个计算机系统的效率。
+
+> [!tip] 考试重点
+> 熟记四个核心评价参数：**连接特性**、**容量**、**响应时间**、**吞吐率**。B 卷选择题已原题考过。
+
+## 正文
+
+### 一、I/O 系统性能的四大评价参数
+
+| 参数 | 英文 | 含义 | 衡量指标 | 示例 |
+|:----:|------|------|----------|------|
+| **连接特性** | Connectivity | I/O 系统能连接的设备种类和数量 | 设备数、通道数、接口类型 | 支持 16 个 SATA 设备 |
+| **容量** | Capacity | I/O 系统能提供的存储空间 | TB、PB | 磁盘阵列 100TB |
+| **响应时间** | Response Time | 从发起 I/O 请求到完成的延迟 | ms、μs | SSD 读延迟 0.1ms |
+| **吞吐率** | Throughput | 单位时间内完成的 I/O 量 | IOPS、MB/s | SSD 顺序读 3500MB/s |
+
+> [!abstract]- 答案
+> 评价 I/O 系统性能的主要参数包括：**连接特性**、**容量**、**响应时间**、**吞吐率**，四个维度缺一不可。
+
+### 二、各参数详解
+
+#### 2.1 连接特性（Connectivity）
+
+描述 I/O 系统的**外部接口能力**：
+
+| 维度 | 说明 |
+|------|------|
+| 设备数量 | 能同时连接的 I/O 设备总数 |
+| 接口类型 | SATA、NVMe、USB、PCIe 等 |
+| 通道数 | 独立的 I/O 通道数量 |
+| 带宽 | 每个通道的传输速率 |
+
+> [!question] 为什么连接特性重要？
+> 一个服务器可能需要连接数十个磁盘、网卡、GPU 加速卡等。如果 I/O 系统的连接能力不足（通道数少、带宽低），就会成为瓶颈，无法充分发挥所有设备的性能。
+
+#### 2.2 容量（Capacity）
+
+I/O 系统能提供的**总存储空间**。
+
+| 存储层次 | 典型容量 | 访问延迟 |
+|:--------:|:--------:|:--------:|
+| L1 Cache | 32~64 KB | ~1 ns |
+| 主存 | 4~64 GB | ~100 ns |
+| SSD | 256 GB~4 TB | ~0.1 ms |
+| HDD | 1~20 TB | ~10 ms |
+| 磁带库 | PB 级 | 秒~分钟 |
+
+#### 2.3 响应时间（Response Time）
+
+从 I/O 请求发出到数据返回的**总延迟**。响应时间的组成：
+
+$$T_{response} = T_{控制器} + T_{寻道} + T_{旋转} + T_{传输} + T_{软件开销}$$
+
+| 组成部分 | 说明 | 典型值 |
+|----------|------|--------|
+| 控制器延迟 | I/O 控制器处理请求的时间 | μs 级 |
+| 寻道时间 | 磁盘磁头移动到目标磁道（仅 HDD） | 3~10 ms |
+| 旋转延迟 | 等待目标扇区旋转到磁头下（仅 HDD） | 2~5 ms |
+| 传输时间 | 数据从设备到内存的实际传输 | 与数据量和带宽有关 |
+| 软件开销 | OS 的 I/O 调度、中断处理等 | μs~ms 级 |
+
+> [!question] SSD 为什么比 HDD 快 100 倍？
+> 主要因为 SSD **没有机械部件**——没有寻道时间和旋转延迟。HDD 的寻道+旋转延迟通常为 5~15ms，而 SSD 的随机读延迟仅 0.05~0.1ms，差距约 100 倍。
+
+#### 2.4 吞吐率（Throughput）
+
+单位时间内 I/O 系统能处理的**数据量**或**操作数**。
+
+| 衡量指标 | 含义 | 适用场景 |
+|----------|------|----------|
+| **MB/s** (GB/s) | 每秒传输的字节数 | 大块数据传输（视频、备份） |
+| **IOPS** | 每秒完成的 I/O 操作数 | 小块随机 I/O（数据库） |
+
+$$\text{吞吐率} = \frac{\text{数据总量}}{\text{总时间}}$$
+
+| 设备类型 | 顺序吞吐率 | 随机 IOPS |
+|:--------:|:----------:|:---------:|
+| HDD (7200RPM) | ~200 MB/s | ~150 |
+| SATA SSD | ~550 MB/s | ~100,000 |
+| NVMe SSD | ~7000 MB/s | ~1,000,000 |
+
+### 三、四个参数之间的关系
+
+```mermaid
+graph TD
+    PERF["I/O System Performance"] --> CONN["Connectivity"]
+    PERF --> CAP["Capacity"]
+    PERF --> RT["Response Time"]
+    PERF --> TP["Throughput"]
+
+    CONN -->|"limits"| TP
+    CAP -->|"influences"| RT
+    RT -->|"inversely related"| TP
+```
+
+> [!note] 参数间的权衡
+> - **响应时间**和**吞吐率**往往是一对矛盾：追求低延迟可能牺牲吞吐率（如逐个快速处理），追求高吞吐率可能增加单个请求的延迟（如批量处理）
+> - **容量**的增加可能影响**响应时间**（更大的存储系统通常需要更复杂的寻址和管理）
+> - **连接特性**决定了系统的**扩展能力**和**最大吞吐率**上限
+
+## 关联笔记
+- [[计算机系统结构/复习文档/总线与IO系统]]
+- [[小题9-总线仲裁与分离事务总线]]
@@ -0,0 +1,137 @@
+---
+tags:
+  - 计算机系统结构
+  - 重点复习
+  - 总线
+  - 仲裁
+  - 分离事务总线
+create time: 2026-06-16 21:21
+---
+
+# 小题 9 — 总线仲裁与分离事务总线
+
+## 概述
+
+本题考查**总线主设备**的概念、**总线仲裁机制**的分类与原理，以及**分离事务总线**的工作原理和别称。总线是计算机系统中各部件通信的公共通道，其仲裁和事务管理直接影响系统性能。
+
+> [!tip] 考试重点
+> 分离事务总线的别称（流水总线、分离协议总线）和非别称（交叉互连总线、独占总线）是 A 卷原题。总线仲裁的三种集中式策略也需要掌握。
+
+## 正文
+
+### 一、总线主设备与从设备
+
+| 类型 | 含义 | 特点 | 示例 |
+|:----:|------|------|------|
+| **主设备**（Master） | 能**主动发起**总线事务的设备 | 拥有总线控制权，可以发起读写操作 | CPU、DMA 控制器 |
+| **从设备**（Slave） | 只能**被动响应**总线事务的设备 | 不发起事务，只响应主设备的请求 | 内存、I/O 接口 |
+
+> [!question] 主设备和从设备的区别？
+> **主设备是"主动方"**——它决定何时使用总线、传输什么数据、传向哪里。**从设备是"被动方"**——它只在被主设备寻址时才响应。例如 CPU（主设备）向内存（从设备）发起读操作：CPU 发出地址和控制信号，内存被动地将数据放到总线上。
+
+### 二、总线仲裁机制
+
+多个主设备可能**同时请求**使用总线，**仲裁器**（Arbiter）决定哪个设备获得总线使用权。
+
+```mermaid
+graph TD
+    REQ["Multiple Bus Masters"] --> ARB["Bus Arbiter"]
+    ARB --> G1["Grant to Master 1"]
+    ARB --> G2["Grant to Master 2"]
+    ARB --> G3["Grant to Master 3"]
+```
+
+#### 2.1 集中式仲裁
+
+由一个**中央仲裁器**统一管理所有总线请求。
+
+| 策略 | 原理 | 优先级 | 优点 | 缺点 |
+|------|------|:------:|------|------|
+| **菊花链** | Grant 信号沿设备链逐级传递 | 离仲裁器近的高 | 简单、线数少 | 不公平，低优先级可能饿死 |
+| **轮询** | 仲裁器按固定顺序轮询各设备 | 动态轮换 | 公平 | 效率不高 |
+| **独立请求** | 每个设备有独立的请求/Grant 线 | 可编程设置 | 灵活、快 | 线数随设备数线性增长 |
+
+> [!note] 三种集中式仲裁的对比
+>
+> | 维度 | 菊花链 | 轮询 | 独立请求 |
+> |:----:|:------:|:----:|:--------:|
+> | 请求线数 | 1 | 1 | $n$ |
+> | Grant 线数 | 1（串行传递） | $\log_2 n$ | $n$ |
+> | 公平性 | 差 | 好 | 可配置 |
+> | 速度 | 慢（链式传递） | 中 | 快 |
+> | 可扩展性 | 好 | 中 | 差（线数多） |
+
+#### 2.2 分布式仲裁
+
+没有中央仲裁器，各设备**自行协商**总线使用权。
+
+| 策略 | 原理 |
+|------|------|
+| 自举分布式 | 每个设备监控比自己优先级高的设备的请求线 |
+| 冲突检测 | 设备发送数据后检测是否发生冲突，冲突则重试 |
+
+> [!question] 什么时候用分布式仲裁？
+> 当系统规模很大（数十到数百个设备）时，集中式仲裁器成为瓶颈。分布式仲裁没有中央瓶颈，适合大规模系统（如以太网的 CSMA/CD 就是一种分布式冲突检测仲裁）。
+
+### 三、分离事务总线
+
+#### 3.1 核心思想
+
+传统总线中，一个事务从**发起请求**到**数据返回**，总线被**全程独占**。即使中间有较长的等待时间（如内存准备数据），其他设备也不能使用总线。
+
+**分离事务总线**将一个总线事务**拆分**为两个独立的子事务：
+1. **请求阶段**：主设备发出地址和命令
+2. **响应阶段**：从设备准备好数据后，独立地将数据返回
+
+两个阶段之间，**总线被释放**，可以为其他设备服务。
+
+```mermaid
+sequenceDiagram
+    participant M1 as "Master 1"
+    participant BUS as "Bus"
+    participant MEM as "Memory"
+    participant M2 as "Master 2"
+
+    M1->>BUS: "Phase 1: Request (addr + cmd)"
+    BUS->>MEM: "Forward to memory"
+    Note over BUS: "Bus released, available"
+    M2->>BUS: "Another request uses bus"
+    BUS->>M2: "Service Master 2"
+    MEM->>BUS: "Phase 2: Response (data ready)"
+    BUS->>M1: "Data delivered to Master 1"
+```
+
+#### 3.2 别称与非别称
+
+> [!abstract]- 答案
+>
+> | 名称 | 是否是分离事务总线的别称 |
+> |:----:|:------------------------:|
+> | **流水总线** | 是 |
+> | **分离协议总线** | 是 |
+> | 交叉互连总线 | **不是**（是另一种总线拓扑） |
+> | 独占总线 | **不是**（独占总线恰恰是分离事务总线的反面） |
+
+> [!note] 为什么"交叉互连总线"和"独占总线"不是别称？
+>
+> **交叉互连总线**（Crossbar Bus）是一种总线**拓扑结构**，允许多对设备之间同时建立独立的连接通道。它与分离事务总线解决的是不同层面的问题——拓扑结构 vs 事务管理。
+>
+> **独占总线**描述的是一个事务**独占总线直到完成**的行为模式，这恰恰是分离事务总线要**解决**的问题。传统总线就是"独占"模式。
+
+#### 3.3 分离事务总线的优势
+
+| 优势 | 说明 |
+|------|------|
+| 提高总线利用率 | 等待期间总线不空闲，可服务其他请求 |
+| 减少总线竞争 | 多个事务可以交错进行 |
+| 提升 I/O 吞吐率 | 多个设备可以同时处于"等待响应"状态 |
+| 适合慢速设备 | 内存访问延迟被隐藏在释放总线期间 |
+
+> [!question] 分离事务总线有什么代价？
+> 1. **硬件复杂度增加**：每个设备需要额外的缓冲寄存器来保存请求信息和返回数据
+> 2. **控制逻辑复杂**：需要跟踪每个未完成事务的状态
+> 3. **响应顺序不确定**：先发出的请求可能后返回，需要排序机制
+
+## 关联笔记
+- [[计算机系统结构/复习文档/总线与IO系统]]
+- [[小题8-IO系统性能评价参数]]