From ff3343cb293a97f51dc2c64afbecf0a4283df5ea Mon Sep 17 00:00:00 2001 From: wonder Date: Tue, 16 Jun 2026 21:34:37 +0800 Subject: [PATCH] vault backup: 2026-06-16 21:34:37 --- 计算机系统结构/重点复习/index.md | 58 ++++ .../重点复习/大题1-CPU性能参数计算.md | 189 ++++++++++++ .../重点复习/大题2-指令操作编码方式.md | 230 +++++++++++++++ .../重点复习/大题3-非线性流水线调度.md | 270 ++++++++++++++++++ .../重点复习/大题4-Cache性能计算.md | 269 +++++++++++++++++ .../重点复习/小题1-冯氏分类法与并行度.md | 102 +++++++ .../重点复习/小题10-并行计算机系统结构分类.md | 150 ++++++++++ 计算机系统结构/重点复习/小题2-流水线的分类.md | 137 +++++++++ .../重点复习/小题3-控制冲突的解决措施.md | 151 ++++++++++ .../重点复习/小题4-流水寄存器的作用.md | 109 +++++++ .../重点复习/小题5-指令级并发的开发方法.md | 135 +++++++++ .../重点复习/小题6-组相联映射与标识存储器.md | 145 ++++++++++ .../重点复习/小题7-Cache不命中与3C模型.md | 145 ++++++++++ .../重点复习/小题8-IO系统性能评价参数.md | 116 ++++++++ .../重点复习/小题9-总线仲裁与分离事务总线.md | 137 +++++++++ 15 files changed, 2343 insertions(+) create mode 100644 计算机系统结构/重点复习/index.md create mode 100644 计算机系统结构/重点复习/大题1-CPU性能参数计算.md create mode 100644 计算机系统结构/重点复习/大题2-指令操作编码方式.md create mode 100644 计算机系统结构/重点复习/大题3-非线性流水线调度.md create mode 100644 计算机系统结构/重点复习/大题4-Cache性能计算.md create mode 100644 计算机系统结构/重点复习/小题1-冯氏分类法与并行度.md create mode 100644 计算机系统结构/重点复习/小题10-并行计算机系统结构分类.md create mode 100644 计算机系统结构/重点复习/小题2-流水线的分类.md create mode 100644 计算机系统结构/重点复习/小题3-控制冲突的解决措施.md create mode 100644 计算机系统结构/重点复习/小题4-流水寄存器的作用.md create mode 100644 计算机系统结构/重点复习/小题5-指令级并发的开发方法.md create mode 100644 计算机系统结构/重点复习/小题6-组相联映射与标识存储器.md create mode 100644 计算机系统结构/重点复习/小题7-Cache不命中与3C模型.md create mode 100644 计算机系统结构/重点复习/小题8-IO系统性能评价参数.md create mode 100644 计算机系统结构/重点复习/小题9-总线仲裁与分离事务总线.md diff --git a/计算机系统结构/重点复习/index.md b/计算机系统结构/重点复习/index.md new file mode 100644 index 0000000..f20719b --- /dev/null +++ b/计算机系统结构/重点复习/index.md @@ -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|试题册索引]] diff --git a/计算机系统结构/重点复习/大题1-CPU性能参数计算.md b/计算机系统结构/重点复习/大题1-CPU性能参数计算.md new file mode 100644 index 0000000..045b685 --- /dev/null +++ b/计算机系统结构/重点复习/大题1-CPU性能参数计算.md @@ -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-冯氏分类法与并行度]] diff --git a/计算机系统结构/重点复习/大题2-指令操作编码方式.md b/计算机系统结构/重点复习/大题2-指令操作编码方式.md new file mode 100644 index 0000000..df21b23 --- /dev/null +++ b/计算机系统结构/重点复习/大题2-指令操作编码方式.md @@ -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性能参数计算]] diff --git a/计算机系统结构/重点复习/大题3-非线性流水线调度.md b/计算机系统结构/重点复习/大题3-非线性流水线调度.md new file mode 100644 index 0000000..f059c40 --- /dev/null +++ b/计算机系统结构/重点复习/大题3-非线性流水线调度.md @@ -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-流水寄存器的作用]] diff --git a/计算机系统结构/重点复习/大题4-Cache性能计算.md b/计算机系统结构/重点复习/大题4-Cache性能计算.md new file mode 100644 index 0000000..7228068 --- /dev/null +++ b/计算机系统结构/重点复习/大题4-Cache性能计算.md @@ -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性能参数计算]] diff --git a/计算机系统结构/重点复习/小题1-冯氏分类法与并行度.md b/计算机系统结构/重点复习/小题1-冯氏分类法与并行度.md new file mode 100644 index 0000000..3ad4b8c --- /dev/null +++ b/计算机系统结构/重点复习/小题1-冯氏分类法与并行度.md @@ -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性能参数计算]] diff --git a/计算机系统结构/重点复习/小题10-并行计算机系统结构分类.md b/计算机系统结构/重点复习/小题10-并行计算机系统结构分类.md new file mode 100644 index 0000000..9218153 --- /dev/null +++ b/计算机系统结构/重点复习/小题10-并行计算机系统结构分类.md @@ -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系统]] diff --git a/计算机系统结构/重点复习/小题2-流水线的分类.md b/计算机系统结构/重点复习/小题2-流水线的分类.md new file mode 100644 index 0000000..16caace --- /dev/null +++ b/计算机系统结构/重点复习/小题2-流水线的分类.md @@ -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-控制冲突的解决措施]] diff --git a/计算机系统结构/重点复习/小题3-控制冲突的解决措施.md b/计算机系统结构/重点复习/小题3-控制冲突的解决措施.md new file mode 100644 index 0000000..13124ad --- /dev/null +++ b/计算机系统结构/重点复习/小题3-控制冲突的解决措施.md @@ -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-流水寄存器的作用]] diff --git a/计算机系统结构/重点复习/小题4-流水寄存器的作用.md b/计算机系统结构/重点复习/小题4-流水寄存器的作用.md new file mode 100644 index 0000000..ea6f4ce --- /dev/null +++ b/计算机系统结构/重点复习/小题4-流水寄存器的作用.md @@ -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-控制冲突的解决措施]] diff --git a/计算机系统结构/重点复习/小题5-指令级并发的开发方法.md b/计算机系统结构/重点复习/小题5-指令级并发的开发方法.md new file mode 100644 index 0000000..adcdd0e --- /dev/null +++ b/计算机系统结构/重点复习/小题5-指令级并发的开发方法.md @@ -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-流水线的分类]] diff --git a/计算机系统结构/重点复习/小题6-组相联映射与标识存储器.md b/计算机系统结构/重点复习/小题6-组相联映射与标识存储器.md new file mode 100644 index 0000000..4e13e20 --- /dev/null +++ b/计算机系统结构/重点复习/小题6-组相联映射与标识存储器.md @@ -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性能计算]] diff --git a/计算机系统结构/重点复习/小题7-Cache不命中与3C模型.md b/计算机系统结构/重点复习/小题7-Cache不命中与3C模型.md new file mode 100644 index 0000000..876c002 --- /dev/null +++ b/计算机系统结构/重点复习/小题7-Cache不命中与3C模型.md @@ -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性能计算]] diff --git a/计算机系统结构/重点复习/小题8-IO系统性能评价参数.md b/计算机系统结构/重点复习/小题8-IO系统性能评价参数.md new file mode 100644 index 0000000..db591db --- /dev/null +++ b/计算机系统结构/重点复习/小题8-IO系统性能评价参数.md @@ -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-总线仲裁与分离事务总线]] diff --git a/计算机系统结构/重点复习/小题9-总线仲裁与分离事务总线.md b/计算机系统结构/重点复习/小题9-总线仲裁与分离事务总线.md new file mode 100644 index 0000000..65148c5 --- /dev/null +++ b/计算机系统结构/重点复习/小题9-总线仲裁与分离事务总线.md @@ -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系统性能评价参数]]