ChoChoX/obsidian
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

vault backup: 2026-07-04 12:12:55

Browse Source
This commit is contained in:
ChoChoX
2026-07-04 12:12:55 +08:00
parent 3aac80fb26
commit ba1ad4e098
21 changed files with 8514 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

194
计算机组成原理/学习笔记/00_计算机组成原理学习指南.md Normal file
View File

@@ -0,0 +1,194 @@
# 计算机组成原理学习指南
> 📚 本笔记基于唐朔飞《计算机组成原理》第3版整理
> 🎯 适合初学者系统学习和考前快速复习
---
## 📖 课程概述
计算机组成原理是计算机科学的核心基础课程，主要研究计算机硬件系统的组成和工作原理。
### 学习目标
- 理解计算机系统的整体架构和工作原理
- 掌握各功能部件的组成和工作方式
- 理解指令的执行过程和数据通路
- 能够分析和设计简单的计算机系统
### 知识体系
```mermaid
graph TD
A[计算机组成原理] --> B[计算机系统概论]
A --> C[系统总线]
A --> D[存储器]
A --> E[输入输出系统]
A --> F[运算方法]
A --> G[指令系统]
A --> H[CPU结构与功能]
A --> I[控制单元功能]
A --> J[控制单元设计]
B --> B1[计算机层次结构]
B --> B2[冯·诺依曼体系]
C --> C1[总线类型]
C --> C2[总线仲裁]
D --> D1[主存储器]
D --> D2[高速缓冲存储器]
D --> D3[虚拟存储器]
E --> E1[IO方式]
E --> E2[程序中断]
F --> F1[定点数运算]
F --> F2[浮点数运算]
G --> G1[指令格式]
G --> G2[寻址方式]
H --> H1[CPU结构]
H --> H2[指令周期]
I --> I1[控制单元功能]
I --> I2[微操作序列]
J --> J1[组合逻辑设计]
J --> J2[微程序设计]
```
---
## 📝 章节笔记
| 章节 | 主题 | 重要程度 | 难度 | 补充版 |
|------|------|----------|------|--------|
| [[01_计算机系统概论]] | 计算机系统基础概念 | ⭐⭐⭐ | 简单 | [[01_计算机系统概论_补充版]] |
| [[03_系统总线]] | 总线结构和工作原理 | ⭐⭐⭐ | 中等 | [[03_系统总线_补充版]] |
| [[04_存储器]] | 存储系统层次结构 | ⭐⭐⭐⭐⭐ | 困难 | [[04_存储器_补充版]] |
| [[05_输入输出系统]] | IO系统工作方式 | ⭐⭐⭐⭐ | 中等 | [[05_输入输出系统_补充版]] |
| [[06_运算方法]] | 数据的表示和运算 | ⭐⭐⭐⭐⭐ | 困难 | [[06_运算方法_补充版]] |
| [[07_指令系统]] | 指令格式和寻址方式 | ⭐⭐⭐⭐ | 中等 | [[07_指令系统_补充版]] |
| [[08_CPU结构与功能]] | CPU组成和工作原理 | ⭐⭐⭐⭐⭐ | 困难 | [[08_CPU结构与功能_补充版]] |
| [[09_控制单元功能]] | 控制单元的基本功能 | ⭐⭐⭐⭐ | 中等 | [[09_控制单元功能_补充版]] |
| [[10_控制单元设计]] | 控制单元的设计方法 | ⭐⭐⭐⭐⭐ | 困难 | [[10_控制单元设计_补充版]] |
---
## 🎯 学习建议
### 初学者学习路径
```
第1章 概论 → 第3章 总线 → 第7章 指令系统 → 第6章 运算方法
↓
第4章 存储器 → 第5章 IO系统 → 第8章 CPU → 第9-10章 控制单元
```
### 复习者快速回顾
1. **重点章节**：第4章（存储器）、第6章（运算方法）、第8章（CPU）、第10章（控制单元设计）
2. **核心概念**：冯·诺依曼体系、存储层次、指令周期、微程序设计
3. **必考内容**：补码运算、Cache映射、中断处理、微指令格式
---
## 📊 重要公式速查
### 数制转换
- 二进制 → 十进制：$\sum_{i=0}^{n} a_i \times 2^i$
- 十进制 → 二进制：除2取余，乘2取整
### 数据表示
- 原码范围：$-(2^{n-1}-1) \sim +(2^{n-1}-1)$
- 补码范围：$-2^{n-1} \sim +(2^{n-1}-1)$
- 移码：$[x]_{移} = 2^{n-1} + x$
### Cache相关
- Cache命中率：$H = \frac{N_c}{N_c + N_m}$
- 平均访问时间：$T_a = HT_c + (1-H)T_m$
- 访问效率：$e = \frac{T_c}{T_a}$
---
## 🔧 实验资源
- [[实验1_中规模组合电路及运算器的应用]]
- [[实验3_基本模型机的数据通路]]
- [[实验4_基本模型机的微程序设计]]
---
## 📚 参考资料
- 教材：《计算机组成原理》第3版 - 唐朔飞
- 复习资料：[[1-10章精简参考复习资料]]
- 习题：[[作业三]]、[[作业四]]
- 试卷：[[样卷2025]]、[[期中考试]]
---
## 💡 学习小贴士
> [!tip] 理解优先
> 计算机组成原理重在理解硬件工作原理，不要死记硬背。多画图、多思考数据流向。
> [!warning] 常见误区
> - 混淆计算机体系结构和计算机组成的概念
> - 不理解补码运算的本质
> - 忽视存储层次的整体性
> [!note] 考试重点
> - 补码加减运算及溢出判断
> - Cache地址映射和替换算法
> - 中断处理过程
> - 微程序设计方法
## 📚 补充版笔记说明
为了帮助更好地理解计算机组成原理的难点，我们为每个章节创建了补充版笔记，增加了以下内容：
### 补充版特点
1. **通俗易懂的解释**：
- 用日常生活中的例子解释抽象概念
- 用类比的方法帮助理解难点
2. **实际例子**：
- 每个概念都有对应的实际例子
- 帮助理解理论在实际中的应用
3. **详细例题**：
- 每个章节都有5道例题
- 包含详细的解题步骤和答案
- 帮助掌握考试重点
4. **深入浅出的讲解**：
- 从简单到复杂，循序渐进
- 帮助建立完整的知识体系
### 如何使用补充版笔记
1. **初学者**：
- 先阅读基础版笔记，了解基本概念
- 再阅读补充版笔记，加深理解
- 做补充版笔记中的例题，巩固知识
2. **复习者**：
- 快速浏览基础版笔记，回顾知识点
- 重点阅读补充版笔记中的例题
- 做补充版笔记中的例题，检验掌握程度
3. **考试前**：
- 重点复习补充版笔记中的例题
- 理解解题思路和方法
- 掌握考试重点和难点
---
*最后更新：2026年7月*

353
计算机组成原理/学习笔记/01_计算机系统概论.md Normal file
View File

@@ -0,0 +1,353 @@
# 第1章 计算机系统概论
> 📖 本章介绍计算机系统的基本概念和组成，是整个课程的基础。
> 🎯 重点理解计算机层次结构和冯·诺依曼体系
---
## 📋 本章目录
- [[#1.1 计算机系统简介]]
- [[#1.2 计算机的基本组成]]
- [[#1.3 计算机硬件的主要技术指标]]
- [[#本章小结]]
---
## 1.1 计算机系统简介
### 1.1.1 计算机的软硬件概念
计算机系统由 **硬件** 和 **软件** 两大部分组成。
```mermaid
graph TB
subgraph 计算机系统
subgraph 硬件
A[主机] --> A1[CPU]
A --> A2[主存储器]
A1 --> A11[运算器]
A1 --> A12[控制器]
B[外部设备] --> B1[输入设备]
B --> B2[输出设备]
end
subgraph 软件
C[系统软件] --> C1[操作系统]
C --> C2[语言处理程序]
C --> C3[数据库管理系统]
D[应用软件] --> D1[科学计算程序]
D --> D2[数据处理程序]
end
end
```
#### 硬件（Hardware）
> [!info] 定义
> 计算机的实体部分，由看得见摸得着的各种电子元器件组成。
- 主机：CPU + 主存储器
- 外部设备：输入设备 + 输出设备
#### 软件（Software）
> [!info] 定义
> 人们事先编制的具有各类特殊功能的程序，存放在存储器中。
**系统软件**：
- 操作系统（Windows、Linux等）
- 语言处理程序（编译程序、汇编程序）
- 数据库管理系统
- 服务程序（诊断、调试程序）
**应用软件**：
- 科学计算程序
- 数据处理程序
- 过程控制程序
- 事务管理程序
> [!tip] 关键理解
> 计算机性能 = 硬件功能 + 软件功能。软硬件相互依存，缺一不可。
---
### 1.1.2 计算机系统的层次结构
计算机系统具有多级层次结构，从低到高依次为：
```mermaid
graph TB
subgraph "五级层次结构"
M4["虚拟机器 M4<br/>(高级语言机器)"] --> |"用编译程序翻译"| M3
M3["虚拟机器 M3<br/>(汇编语言机器)"] --> |"用汇编程序翻译"| M2
M2["虚拟机器 M2<br/>(操作系统机器)"] --> |"用机器语言解释"| M1
M1["传统机器 M1<br/>(机器语言机器)"] --> |"用微程序解释"| M0
M0["微程序机器 M0<br/>(微指令系统)"] --> |"由硬件直接执行"| HW["硬件电路"]
end
style M4 fill:#e1f5fe
style M3 fill:#b3e5fc
style M2 fill:#81d4fa
style M1 fill:#4fc3f7
style M0 fill:#29b6f6
style HW fill:#0288d1
```
#### 各层次说明
| 层次 | 名称 | 说明 | 语言 |
|------|------|------|------|
| M4 | 高级语言机器 | 用户编程层面 | 高级语言（C、Java等） |
| M3 | 汇编语言机器 | 汇编语言层面 | 汇编语言 |
| M2 | 操作系统机器 | 操作系统层面 | 机器语言 |
| M1 | 传统机器 | 硬件指令层面 | 机器语言 |
| M0 | 微程序机器 | 微指令层面 | 微指令 |
> [!note] 重要概念
> - **虚拟机**：不是实际存在的机器，而是通过软件实现的功能层次
> - **实际机器**：物理存在的硬件机器（M0和M1）
> - **软硬件交界**：随着技术发展，部分软件功能由硬件实现（固件）
#### 翻译程序的两种方式
```mermaid
graph LR
subgraph "编译程序"
A1[源程序] --> B1[一次性全部翻译] --> C1[目标程序] --> D1[执行]
end
subgraph "解释程序"
A2[源程序] --> B2[翻译一条] --> C2[执行一条] --> D2[下一条]
D2 --> B2
end
```
- **编译程序**：一次性全部翻译，然后执行（如C、Pascal）
- **解释程序**：边翻译边执行（如BASIC）
---
### 1.1.3 计算机组成和计算机体系结构
这两个概念容易混淆，需要明确区分：
| 概念 | 定义 | 关注点 | 示例 |
|------|------|--------|------|
| 计算机体系结构 | 程序员所见到的计算机属性 | 指令集、数据类型、寻址技术 | 是否有乘法指令 |
| 计算机组成 | 体系结构的实现方式 | 硬件细节、电路实现 | 乘法指令用专用电路还是加法器实现 |
> [!example] 举例说明
> IBM System/370系列：
> - **体系结构相同**：所有机型指令集相同
> - **组成不同**：不同型号性能、价格差异很大
> - **好处**：用户软件投资得到保护
---
## 1.2 计算机的基本组成
### 1.2.1 冯·诺依曼计算机的特点
> [!important] 冯·诺依曼体系（1945年）
> 基于"存储程序"概念的计算机体系结构
**五大特点**：
1. 计算机由 **运算器、存储器、控制器、输入设备、输出设备** 五大部件组成
2. 指令和数据以同等地位存放于存储器内，并可按地址寻访
3. 指令和数据均用 **二进制数** 表示
4. 指令由 **操作码** 和 **地址码** 组成
5. 指令在存储器内按顺序存放，通常顺序执行
```mermaid
graph TB
subgraph "冯·诺依曼计算机结构"
direction TB
CU[控制器] --> |"控制信号"| ALU[运算器]
CU --> |"控制信号"| MEM[存储器]
CU --> |"控制信号"| IN[输入设备]
CU --> |"控制信号"| OUT[输出设备]
IN --> |"数据"| MEM
MEM --> |"数据"| ALU
ALU --> |"数据"| MEM
MEM --> |"数据"| OUT
end
style CU fill:#ff9999
style ALU fill:#99ccff
style MEM fill:#99ff99
style IN fill:#ffcc99
style OUT fill:#cc99ff
```
### 1.2.2 计算机的硬件框图
#### 传统结构（以运算器为中心）
```mermaid
graph LR
IN[输入设备] --> |"数据"| ALU[运算器]
ALU --> |"数据"| MEM[存储器]
MEM --> |"数据"| ALU
ALU --> |"数据"| OUT[输出设备]
CU[控制器] --> |"控制"| ALU
CU --> |"控制"| MEM
CU --> |"控制"| IN
CU --> |"控制"| OUT
```
#### 现代结构（以存储器为中心）
```mermaid
graph TB
IN[输入设备] --> |"数据"| MEM[存储器]
MEM --> |"数据"| OUT[输出设备]
MEM --> |"数据"| ALU[运算器]
ALU --> |"数据"| MEM
CU[控制器] --> |"控制信号"| ALU
CU --> |"控制信号"| MEM
CU --> |"控制信号"| IN
CU --> |"控制信号"| OUT
```
> [!tip] 结构变化的原因
> 以存储器为中心可以减少数据传输的瓶颈，提高系统效率。
### 1.2.3 各部件功能详解
| 部件 | 功能 | 关键特性 |
|------|------|----------|
| **运算器** | 完成算术运算和逻辑运算 | 暂存中间结果 |
| **存储器** | 存放数据和程序 | 按地址访问 |
| **控制器** | 控制指挥程序运行 | 产生控制信号 |
| **输入设备** | 信息形式转换（人→机） | 键盘、鼠标等 |
| **输出设备** | 信息形式转换（机→人） | 显示器、打印机等 |
### 1.2.4 现代计算机组成
```mermaid
graph TB
subgraph "现代计算机组成"
subgraph "主机"
CPU["CPU"] --> ALU["运算器"]
CPU --> CU["控制器"]
MM["主存储器<br/>(主存)"]
end
subgraph "外部设备"
IO["I/O设备"] --> INPUT["输入设备"]
IO --> OUTPUT["输出设备"]
end
end
CPU <--> |"数据/地址"| MM
CPU <--> |"数据"| IO
MM <--> |"数据"| IO
style CPU fill:#ff9999
style MM fill:#99ff99
style IO fill:#99ccff
```
**术语说明**：
- **CPU** = 运算器 + 控制器
- **主机** = CPU + 主存储器
- **I/O设备** = 输入设备 + 输出设备（外部设备）
---
## 1.3 计算机硬件的主要技术指标
### 1.3.1 机器字长
> [!info] 定义
> CPU一次能处理数据的位数，通常与CPU寄存器位数有关。
- 影响：字长越长，计算精度越高
- 常见：8位、16位、32位、64位
### 1.3.2 存储容量
> [!info] 定义
> 存储器能存放二进制代码的总位数
**计算公式**：
$$存储容量 = 存储单元数 \times 存储字长$$
**单位换算**：
- 1KB = 1024B
- 1MB = 1024KB
- 1GB = 1024MB
- 1TB = 1024GB
### 1.3.3 运算速度
**常用指标**：
| 指标 | 说明 | 计算方式 |
|------|------|----------|
| MIPS | 每秒百万条指令 | 指令数 / 执行时间 |
| CPI | 每条指令时钟周期数 | 时钟周期数 / 指令数 |
| FLOPS | 每秒浮点运算次数 | 浮点运算数 / 执行时间 |
### 1.3.4 其他指标
- **主频**：CPU时钟频率（GHz）
- **带宽**：数据传输速率（MB/s）
- **兼容性**：软件在不同机器上的通用性
---
## 📝 本章小结
### 核心概念
1. **计算机系统** = 硬件 + 软件
2. **层次结构**：从微程序机器到高级语言机器的多级层次
3. **冯·诺依曼体系**：存储程序、五大部件、二进制表示
4. **现代计算机**：以存储器为中心，CPU = 运算器 + 控制器
### 关键术语
| 术语 | 英文 | 含义 |
|------|------|------|
| CPU | Central Processing Unit | 中央处理器 |
| ALU | Arithmetic Logic Unit | 算术逻辑单元 |
| CU | Control Unit | 控制单元 |
| MM | Main Memory | 主存储器 |
| I/O | Input/Output | 输入输出 |
### 重点图示
> [!summary] 必须掌握的图
> 1. 计算机系统层次结构图
> 2. 冯·诺依曼计算机结构框图
> 3. 现代计算机组成框图（以存储器为中心）
---
## 🧪 自测练习
### 概念题
1. 简述计算机硬件和软件的关系。
2. 画出计算机系统的五级层次结构，并说明各层功能。
3. 冯·诺依曼计算机有哪些特点？
### 思考题
1. 为什么要区分计算机体系结构和计算机组成？
2. 现代计算机为什么采用以存储器为中心的结构？
---
## 🔗 相关链接
- [[00_计算机组成原理学习指南]] - 返回主目录
- [[03_系统总线]] - 下一章
- [[06_运算方法]] - 数据表示相关内容
- [[08_CPU结构与功能]] - CPU详细设计
---
*本章难度：⭐⭐ 简单*
*重要程度：⭐⭐⭐ 基础*

472
计算机组成原理/学习笔记/01_计算机系统概论_补充版.md Normal file
View File

@@ -0,0 +1,472 @@
# 第1章 计算机系统概论
> 📖 本章介绍计算机系统的基本概念和组成，是整个课程的基础。
> 🎯 重点理解计算机层次结构和冯·诺依曼体系
---
## 📋 本章目录
- [[#1.1 计算机系统简介]]
- [[#1.2 计算机的基本组成]]
- [[#1.3 计算机硬件的主要技术指标]]
- [[#本章小结]]
- [[#例题与解析]]
---
## 1.1 计算机系统简介
### 1.1.1 计算机的软硬件概念
计算机系统由 **硬件** 和 **软件** 两大部分组成。
```mermaid
graph TB
subgraph 计算机系统
subgraph 硬件
A[主机] --> A1[CPU]
A --> A2[主存储器]
A1 --> A11[运算器]
A1 --> A12[控制器]
B[外部设备] --> B1[输入设备]
B --> B2[输出设备]
end
subgraph 软件
C[系统软件] --> C1[操作系统]
C --> C2[语言处理程序]
C --> C3[数据库管理系统]
D[应用软件] --> D1[科学计算程序]
D --> D2[数据处理程序]
end
end
```
#### 硬件（Hardware）
> [!info] 定义
> 计算机的实体部分，由看得见摸得着的各种电子元器件组成。
- 主机：CPU + 主存储器
- 外部设备：输入设备 + 输出设备
理解硬件最好的方式是类比人体：CPU就像大脑，负责思考和处理信息；内存相当于短期记忆，临时存放正在处理的信息；硬盘是长期记忆，永久保存数据；键盘鼠标像眼睛和耳朵，接收外界输入；显示器则是嘴巴和手，把处理结果输出给我们。
#### 软件（Software）
> [!info] 定义
> 人们事先编制的具有各类特殊功能的程序，存放在存储器中。
**系统软件**：
- 操作系统（Windows、Linux等）
- 语言处理程序（编译程序、汇编程序）
- 数据库管理系统
- 服务程序（诊断、调试程序）
**应用软件**：
- 科学计算程序
- 数据处理程序
- 过程控制程序
- 事务管理程序
软件可以类比为人的思想和知识：操作系统就像基本生活技能（吃饭、走路），编译程序像翻译官，把高级语言翻译成机器能懂的语言，应用软件则是各种专业知识和技能。
> [!tip] 关键理解
> 计算机性能 = 硬件功能 + 软件功能。软硬件相互依存，缺一不可。
举个实际的例子：一台高性能电脑如果没有安装任何软件，什么都做不了；反过来，再厉害的软件在配置太低的硬件上也跑不起来。所以硬件和软件必须配合才能发挥作用。
---
### 1.1.2 计算机系统的层次结构
计算机系统具有多级层次结构，从低到高依次为：
```mermaid
graph TB
subgraph "五级层次结构"
M4["虚拟机器 M4<br/>(高级语言机器)"] --> |"用编译程序翻译"| M3
M3["虚拟机器 M3<br/>(汇编语言机器)"] --> |"用汇编程序翻译"| M2
M2["虚拟机器 M2<br/>(操作系统机器)"] --> |"用机器语言解释"| M1
M1["传统机器 M1<br/>(机器语言机器)"] --> |"用微程序解释"| M0
M0["微程序机器 M0<br/>(微指令系统)"] --> |"由硬件直接执行"| HW["硬件电路"]
end
style M4 fill:#e1f5fe
style M3 fill:#b3e5fc
style M2 fill:#81d4fa
style M1 fill:#4fc3f7
style M0 fill:#29b6f6
style HW fill:#0288d1
```
#### 各层次说明
| 层次 | 名称 | 说明 | 语言 |
|------|------|------|------|
| M4 | 高级语言机器 | 用户编程层面 | 高级语言（C、Java等） |
| M3 | 汇编语言机器 | 汇编语言层面 | 汇编语言 |
| M2 | 操作系统机器 | 操作系统层面 | 机器语言 |
| M1 | 传统机器 | 硬件指令层面 | 机器语言 |
| M0 | 微程序机器 | 微指令层面 | 微指令 |
这个层次结构可以想象成一栋大楼：顶层（M4）是普通用户工作的地方，他们用C、Java等高级语言编程，就像说普通话一样自然；往下一层（M3）是专业程序员，用汇编语言，更接近机器但人还能听懂；再往下（M2）是系统管理员，管理整栋大楼的资源；底层（M1）是硬件工程师，直接操作机器指令；最底层（M0）是硬件电路，执行最基础的微指令，就像大楼的地基。
当我们用C语言写 `int a = 5 + 3;` 时，这个简单的加法在不同层次的表现是不同的：M4层看到的是 `5 + 3`，M3层编译器把它翻译成汇编指令，M2层操作系统负责分配资源，M1层变成二进制机器指令，M0层则是微指令控制ALU执行加法。
> [!note] 重要概念
> - **虚拟机**：不是实际存在的机器，而是通过软件实现的功能层次
> - **实际机器**：物理存在的硬件机器（M0和M1）
> - **软硬件交界**：随着技术发展，部分软件功能由硬件实现（固件）
#### 翻译程序的两种方式
```mermaid
graph LR
subgraph "编译程序"
A1[源程序] --> B1[一次性全部翻译] --> C1[目标程序] --> D1[执行]
end
subgraph "解释程序"
A2[源程序] --> B2[翻译一条] --> C2[执行一条] --> D2[下一条]
D2 --> B2
end
```
- **编译程序**：一次性全部翻译，然后执行（如C、Pascal）
- **解释程序**：边翻译边执行（如BASIC）
这两种方式的区别可以用看英文小说来理解：编译程序就像请翻译把整本小说翻译成中文，然后你读中文版，优点是读得快，缺点是翻译时间长；解释程序就像翻译坐在旁边，你读一句英文他翻译一句中文给你听，优点是马上能开始读，缺点是读得慢。
实际应用中，C语言用编译方式，先把 `.c` 文件编译成 `.exe` 文件再运行；Python用解释方式，边翻译边执行，不需要生成单独的可执行文件。
---
### 1.1.3 计算机组成和计算机体系结构
这两个概念容易混淆，需要明确区分：
| 概念 | 定义 | 关注点 | 示例 |
|------|------|--------|------|
| 计算机体系结构 | 程序员所见到的计算机属性 | 指令集、数据类型、寻址技术 | 是否有乘法指令 |
| 计算机组成 | 体系结构的实现方式 | 硬件细节、电路实现 | 乘法指令用专用电路还是加法器实现 |
区分这两个概念可以类比买汽车：体系结构就像汽车的"功能规格"（几个座位、最高时速、有没有天窗），组成则是"具体实现"（发动机是V6还是V8、变速箱是手动还是自动）。
IBM System/370系列就是很好的例子：所有机型的体系结构相同（指令集一样），但组成不同（不同型号性能、价格差异很大），这样用户的软件投资就能得到保护。
> [!example] 举例说明
> 就像iPhone和Android手机：体系结构不同（指令集、系统调用完全不同），但组成可以相同（可能都用ARM处理器），所以iOS应用不能直接在Android上运行。
---
## 1.2 计算机的基本组成
### 1.2.1 冯·诺依曼计算机的特点
> [!important] 冯·诺依曼体系（1945年）
> 基于"存储程序"概念的计算机体系结构
**五大特点**：
1. 计算机由 **运算器、存储器、控制器、输入设备、输出设备** 五大部件组成
2. 指令和数据以同等地位存放于存储器内，并可按地址寻访
3. 指令和数据均用 **二进制数** 表示
4. 指令由 **操作码** 和 **地址码** 组成
5. 指令在存储器内按顺序存放，通常顺序执行
```mermaid
graph TB
subgraph "冯·诺依曼计算机结构"
direction TB
CU[控制器] --> |"控制信号"| ALU[运算器]
CU --> |"控制信号"| MEM[存储器]
CU --> |"控制信号"| IN[输入设备]
CU --> |"控制信号"| OUT[输出设备]
IN --> |"数据"| MEM
MEM --> |"数据"| ALU
ALU --> |"数据"| MEM
MEM --> |"数据"| OUT
end
style CU fill:#ff9999
style ALU fill:#99ccff
style MEM fill:#99ff99
style IN fill:#ffcc99
style OUT fill:#cc99ff
```
冯·诺依曼体系可以理解为一个高效的工厂：运算器是生产车间，负责加工产品；存储器是仓库，存放原材料和成品；控制器是厂长，指挥整个生产过程；输入设备是采购部，接收订单和原材料；输出设备是销售部，把成品交给客户。"存储程序"的概念就是把生产计划（程序）和原材料（数据）都放在仓库里，厂长按计划指挥生产。
当你用电脑计算 `5 + 3` 时，整个过程是这样的：键盘输入数据，存储器存放数字和指令，控制器指挥运算器执行加法，运算器计算结果，最后显示器显示答案。
### 1.2.2 计算机的硬件框图
#### 传统结构（以运算器为中心）
```mermaid
graph LR
IN[输入设备] --> |"数据"| ALU[运算器]
ALU --> |"数据"| MEM[存储器]
MEM --> |"数据"| ALU
ALU --> |"数据"| OUT[输出设备]
CU[控制器] --> |"控制"| ALU
CU --> |"控制"| MEM
CU --> |"控制"| IN
CU --> |"控制"| OUT
```
#### 现代结构（以存储器为中心）
```mermaid
graph TB
IN[输入设备] --> |"数据"| MEM[存储器]
MEM --> |"数据"| OUT[输出设备]
MEM --> |"数据"| ALU[运算器]
ALU --> |"数据"| MEM
CU[控制器] --> |"控制信号"| ALU
CU --> |"控制信号"| MEM
CU --> |"控制信号"| IN
CU --> |"控制信号"| OUT
```
> [!tip] 结构变化的原因
> 以存储器为中心可以减少数据传输的瓶颈，提高系统效率。
从传统结构到现代结构的变化，可以用快递公司来理解：传统结构中，所有快递都要经过分拣中心（运算器），即使是从仓库直接发给客户的也要先绕一圈，效率很低；现代结构中，仓库可以直接发货给客户，分拣中心只处理需要加工的快递，效率大大提高。
比如从硬盘复制文件到U盘时，传统结构需要经过CPU，现代结构则可以直接通过内存传输，不占用CPU资源。
### 1.2.3 各部件功能详解
| 部件 | 功能 | 关键特性 |
|------|------|----------|
| **运算器** | 完成算术运算和逻辑运算 | 暂存中间结果 |
| **存储器** | 存放数据和程序 | 按地址访问 |
| **控制器** | 控制指挥程序运行 | 产生控制信号 |
| **输入设备** | 信息形式转换（人→机） | 键盘、鼠标等 |
| **输出设备** | 信息形式转换（机→人） | 显示器、打印机等 |
把这些部件想象成一个餐厅：运算器是厨师，负责加工食材，能做各种菜，会把做好的菜暂时放在操作台上；存储器是冰箱和货架，存放食材和菜谱，每个格子都有编号，需要什么直接去对应编号的格子拿；控制器是餐厅经理，看订单决定做什么菜，指挥厨师工作，协调各部门配合；输入设备是服务员，接收顾客点单，把点单翻译成厨房能懂的语言；输出设备是传菜员，把做好的菜端给顾客。
### 1.2.4 现代计算机组成
```mermaid
graph TB
subgraph "现代计算机组成"
subgraph "主机"
CPU["CPU"] --> ALU["运算器"]
CPU --> CU["控制器"]
MM["主存储器<br/>(主存)"]
end
subgraph "外部设备"
IO["I/O设备"] --> INPUT["输入设备"]
IO --> OUTPUT["输出设备"]
end
end
CPU <--> |"数据/地址"| MM
CPU <--> |"数据"| IO
MM <--> |"数据"| IO
style CPU fill:#ff9999
style MM fill:#99ff99
style IO fill:#99ccff
```
**术语说明**：
- **CPU** = 运算器 + 控制器
- **主机** = CPU + 主存储器
- **I/O设备** = 输入设备 + 输出设备（外部设备）
现代计算机就像一个现代化的办公大楼：CPU是总经理办公室，其中运算器是财务部负责计算，控制器是总经理指挥全局；主存储器是办公桌，临时存放正在处理的文件，速度快但容量小；外部设备包括前台（输入设备）和公关部（输出设备）。
---
## 1.3 计算机硬件的主要技术指标
### 1.3.1 机器字长
> [!info] 定义
> CPU一次能处理数据的位数，通常与CPU寄存器位数有关。
- 影响：字长越长，计算精度越高
- 常见：8位、16位、32位、64位
机器字长可以理解为工人一次能搬多少东西：8位工人一次搬8块砖，16位搬16块，32位搬32块，64位搬64块。搬得越多，处理速度越快，计算精度越高。早期的单片机是8位，大多数嵌入式系统是32位，现代个人电脑和服务器是64位。
### 1.3.2 存储容量
> [!info] 定义
> 存储器能存放二进制代码的总位数
**计算公式**：
$$存储容量 = 存储单元数 \times 存储字长$$
**单位换算**：
- 1KB = 1024B
- 1MB = 1024KB
- 1GB = 1024MB
- 1TB = 1024GB
存储容量就像仓库的大小：存储单元数是仓库有多少个格子，存储字长是每个格子能放多少东西，两者相乘就是总容量。比如一个仓库有1024个格子，每个格子能放8个鸡蛋，总容量就是1024×8=8192个鸡蛋，也就是1KB。
### 1.3.3 运算速度
**常用指标**：
| 指标 | 说明 | 计算方式 |
|------|------|----------|
| MIPS | 每秒百万条指令 | 指令数 / 执行时间 |
| CPI | 每条指令时钟周期数 | 时钟周期数 / 指令数 |
| FLOPS | 每秒浮点运算次数 | 浮点运算数 / 执行时间 |
这三个指标可以这样理解：MIPS是工人每秒能处理多少个订单，CPI是处理一个订单需要多少个步骤，FLOPS是每秒能计算多少道数学题。MIPS越高处理越快，CPI越低效率越高，FLOPS越强计算能力越强。
### 1.3.4 其他指标
- **主频**：CPU时钟频率（GHz）
- **带宽**：数据传输速率（MB/s）
- **兼容性**：软件在不同机器上的通用性
主频就像工人的心跳速度，主频越高干活越快，但不一定效率高；带宽就像高速公路的车道数，车道越多能通过的车辆越多；兼容性就像不同品牌的手机能不能用同一个充电器。
---
## 📝 本章小结
### 核心概念
1. **计算机系统** = 硬件 + 软件
2. **层次结构**：从微程序机器到高级语言机器的多级层次
3. **冯·诺依曼体系**：存储程序、五大部件、二进制表示
4. **现代计算机**：以存储器为中心，CPU = 运算器 + 控制器
### 关键术语
| 术语 | 英文 | 含义 |
|------|------|------|
| CPU | Central Processing Unit | 中央处理器 |
| ALU | Arithmetic Logic Unit | 算术逻辑单元 |
| CU | Control Unit | 控制单元 |
| MM | Main Memory | 主存储器 |
| I/O | Input/Output | 输入输出 |
### 重点图示
> [!summary] 必须掌握的图
> 1. 计算机系统层次结构图
> 2. 冯·诺依曼计算机结构框图
> 3. 现代计算机组成框图（以存储器为中心）
---
## 🧪 例题与解析
### 例题1：计算机层次结构
**题目**：简述计算机系统的五级层次结构，并说明各层的作用。
**答案**：
计算机系统的五级层次结构从低到高依次为：
1. **微程序机器M0（微指令系统）**：执行最基础的微指令，由硬件直接执行，速度最快。比如控制ALU执行加法操作的微指令。
2. **传统机器M1（机器语言机器）**：执行机器语言程序，直接执行二进制指令。比如执行 `000001 0000000101` 这样的机器指令。
3. **虚拟机器M2（操作系统机器）**：管理计算机资源，提供系统服务。比如Windows管理内存分配、进程调度。
4. **虚拟机器M3（汇编语言机器）**：执行汇编语言程序，用汇编程序翻译成机器语言。比如执行 `ADD R1, R2, R3` 这样的汇编指令。
5. **虚拟机器M4（高级语言机器）**：执行高级语言程序，用编译程序翻译成汇编语言或机器语言。比如执行 `int a = 5 + 3;` 这样的C语言语句。
这就像一栋5层大楼：1楼是地基和电路，2楼是生产车间，3楼是管理部门，4楼是设计部门，5楼是销售部门。
### 例题2：编译与解释
**题目**：比较编译程序和解释程序的区别，并举例说明。
**答案**：
| 特性 | 编译程序 | 解释程序 |
|------|----------|----------|
| 翻译方式 | 一次性全部翻译 | 边翻译边执行 |
| 执行速度 | 快（已翻译成目标程序） | 慢（每次都要翻译） |
| 错误处理 | 编译时发现所有错误 | 运行时逐行发现错误 |
| 代表语言 | C、Pascal、FORTRAN | BASIC、Python、JavaScript |
编译程序就像请翻译把整本小说翻译成中文，然后你读中文版，读得快但翻译时间长；解释程序就像翻译坐在旁边，你读一句他翻译一句，马上能开始读但读得慢。
C语言是编译型：`hello.c` → `gcc` → `hello.exe` → 运行；Python是解释型：`python hello.py` → 边翻译边执行。
### 例题3：冯·诺依曼体系
**题目**：简述冯·诺依曼计算机的特点，并说明为什么现代计算机采用以存储器为中心的结构。
**答案**：
冯·诺依曼计算机的五大特点：五大部件组成（运算器、存储器、控制器、输入设备、输出设备）；存储程序概念（指令和数据同等地位存放于存储器）；二进制表示；指令格式（操作码+地址码）；顺序执行。
现代计算机采用以存储器为中心的结构，主要是为了减少数据传输瓶颈、提高系统效率。传统结构中所有数据都要经过运算器，现代结构中存储器可以直接与I/O设备交换数据，CPU可以专心处理计算任务，I/O操作不占用CPU时间。
比如从硬盘复制文件到U盘时，传统结构需要经过CPU，现代结构可以直接通过内存传输，效率更高。
### 例题4：技术指标计算
**题目**：某计算机主频为2GHz，CPI为4，求该计算机的MIPS。
**答案**：
主频2GHz = 2×10⁹ Hz，CPI=4，代入公式：
$$MIPS = \frac{主频}{CPI \times 10^6} = \frac{2 \times 10^9}{4 \times 10^6} = 500$$
该计算机的MIPS为500，即每秒执行5亿条指令。
可以理解为：心跳速度（主频）每秒跳20亿次，每个订单需要4次心跳（CPI=4），每秒能处理20亿÷4=5亿个订单。
### 例题5：存储容量计算
**题目**：某计算机存储器有16位地址线，8位数据线，求该存储器的容量。
**答案**：
16位地址线可以表示 2¹⁶ = 65536 个地址，即有65536个存储单元；8位数据线表示每个单元存8位数据（1字节）。
存储容量 = 65536 × 8位 = 65536字节 = 64KB。
这就像一个仓库有65536个格子，每个格子能放8个鸡蛋，总容量就是64KB。
---
## ⚡ 知识点速记卡
> 考前快速过一遍，30秒回忆整章核心
**计算机系统 = 硬件 + 软件**，两者缺一不可。
**五级层次**（从下往上）：微程序机器M0 → 传统机器M1 → 操作系统M2 → 汇编语言M3 → 高级语言M4。底下两层是实际机器，上面三层是虚拟机器。
**冯·诺依曼五大特点**：①五大部件（运算器+存储器+控制器+输入+输出）②存储程序（指令和数据同等地位存放）③二进制表示 ④指令=操作码+地址码 ⑤顺序执行。
**现代计算机**以存储器为中心（不是运算器），CPU = 运算器 + 控制器，主机 = CPU + 主存。
**三个速度指标**：MIPS（每秒百万条指令，越大越快）、CPI（每条指令时钟周期数，越小越高效）、FLOPS（每秒浮点运算次数）。
**编译 vs 解释**：编译一次性全部翻译再执行（C），解释边翻译边执行（Python）。编译快但调试慢，解释慢但调试快。
**容量计算**：存储容量 = 存储单元数 × 字长。20位地址线 → 2²⁰ = 1M个单元。
---
## 🔗 相关链接
- [[00_计算机组成原理学习指南]] - 返回主目录
- [[03_系统总线]] - 下一章
- [[06_运算方法]] - 数据表示相关内容
- [[08_CPU结构与功能]] - CPU详细设计
---
*本章难度：⭐⭐ 简单*
*重要程度：⭐⭐⭐ 基础*

423
计算机组成原理/学习笔记/03_系统总线.md Normal file
View File

@@ -0,0 +1,423 @@
# 第3章 系统总线
> 📖 本章介绍系统总线的基本概念、分类和控制逻辑。
> 🎯 重点理解总线结构和总线仲裁方式
---
## 📋 本章目录
- [[#3.1 总线的基本概念]]
- [[#3.2 总线的分类]]
- [[#3.3 总线特性及性能指标]]
- [[#3.4 总线结构]]
- [[#3.5 总线控制]]
- [[#本章小结]]
---
## 3.1 总线的基本概念
### 3.1.1 什么是总线
> [!info] 定义
> 总线是连接多个部件的信息传输线，是各部件**共享**的传输介质。
**关键特性**：
- 同一时刻只允许**一个部件**向总线发送信息
- 多个部件可以**同时**从总线上接收相同的信息
```mermaid
graph TB
subgraph "总线结构"
CPU[CPU] <--> |"共享总线"| BUS[系统总线]
MEM[主存] <--> |"共享总线"| BUS
IO1[I/O设备1] <--> |"共享总线"| BUS
IO2[I/O设备2] <--> |"共享总线"| BUS
IO3[I/O设备3] <--> |"共享总线"| BUS
end
style BUS fill:#ffcc00
```
### 3.1.2 总线连接方式
#### 分散连接 vs 总线连接
| 特性 | 分散连接 | 总线连接 |
|------|----------|----------|
| 连线方式 | 各部件单独连线 | 共享传输线 |
| 灵活性 | 差，增删设备困难 | 好，便于扩展 |
| 复杂度 | 高 | 低 |
| 成本 | 高 | 低 |
### 3.1.3 总线结构类型
#### 1. 面向CPU的双总线结构
```mermaid
graph TB
subgraph "面向CPU的双总线"
CPU[CPU] <--> |"M总线"| MEM[主存]
CPU <--> |"I/O总线"| IO1[I/O设备1]
CPU <--> |"I/O总线"| IO2[I/O设备2]
CPU <--> |"I/O总线"| ION[I/O设备n]
end
style CPU fill:#ff9999
style MEM fill:#99ff99
```
**特点**：
- 两组总线：M总线（存储总线）和I/O总线
- I/O设备与主存交换信息需经过CPU
- 影响CPU工作效率
#### 2. 单总线结构
```mermaid
graph TB
subgraph "单总线结构"
CPU[CPU] <--> |"系统总线"| BUS[系统总线]
MEM[主存] <--> |"系统总线"| BUS
IO1[I/O设备1] <--> |"系统总线"| BUS
IO2[I/O设备2] <--> |"系统总线"| BUS
ION[I/O设备n] <--> |"系统总线"| BUS
end
style BUS fill:#ffcc00
```
**特点**：
- 所有部件挂到同一组总线
- I/O与主存交换信息不占用CPU
- 需要总线判优逻辑解决冲突
#### 3. 以存储器为中心的双总线结构
```mermaid
graph TB
subgraph "以存储器为中心的双总线"
CPU[CPU] <--> |"存储总线"| MEM[主存]
MEM <--> |"系统总线"| IO1[I/O设备1]
MEM <--> |"系统总线"| IO2[I/O设备2]
MEM <--> |"系统总线"| ION[I/O设备n]
CPU <--> |"系统总线"| IO1
CPU <--> |"系统总线"| IO2
CPU <--> |"系统总线"| ION
end
style CPU fill:#ff9999
style MEM fill:#99ff99
```
**特点**：
- 在单总线基础上增加CPU与主存的专用总线
- 提高传输效率，减轻系统总线负担
- I/O与存储器交换信息不经过CPU
---
## 3.2 总线的分类
### 按连接部件分类
```mermaid
graph LR
A[总线分类] --> B[片内总线]
A --> C[系统总线]
A --> D[通信总线]
B --> B1[芯片内部总线]
C --> C1[数据总线]
C --> C2[地址总线]
C --> C3[控制总线]
D --> D1[串行通信]
D --> D2[并行通信]
```
### 3.2.1 片内总线
> [!info] 定义
> 芯片内部的总线，如CPU芯片内部寄存器之间、寄存器与ALU之间的连线。
### 3.2.2 系统总线
系统总线传输三类信息：
#### 数据总线（Data Bus）
| 特性 | 说明 |
|------|------|
| 传输内容 | 各功能部件之间的数据信息 |
| 传输方向 | **双向**传输 |
| 位数 | 与机器字长、存储字长有关（8/16/32位） |
| 影响 | 数据总线宽度影响系统性能 |
> [!example] 示例
> 数据总线宽度为8位，指令字长为16位，则取指需**两次**访问主存。
#### 地址总线（Address Bus）
| 特性 | 说明 |
|------|------|
| 传输内容 | 指明CPU欲访问的存储单元或I/O端口地址 |
| 传输方向 | **单向**（由CPU输出） |
| 位数 | 与存储单元个数有关 |
| 计算 | n位地址线 → $2^n$ 个存储单元 |
> [!example] 示例
> 20根地址线 → $2^{20} = 1M$ 个存储单元
#### 控制总线（Control Bus）
| 特性 | 说明 |
|------|------|
| 传输内容 | 各种控制信号和状态信号 |
| 传输方向 | 单根单向，总体**双向** |
| 功能 | 控制总线使用权、同步操作、状态反馈 |
**常见控制信号**：
| 信号 | 方向 | 功能 |
|------|------|------|
| 时钟 | CPU→ | 同步各种操作 |
| 复位 | CPU→ | 初始化所有部件 |
| 总线请求 | ←部件 | 部件请求总线使用权 |
| 总线允许 | CPU→ | 授予总线使用权 |
| 中断请求 | ←部件 | 部件提出中断请求 |
| 中断响应 | CPU→ | 接收中断请求 |
| 存储器读 | CPU→ | 从存储器读数据 |
| 存储器写 | CPU→ | 向存储器写数据 |
| I/O读 | CPU→ | 从I/O端口读数据 |
| I/O写 | CPU→ | 向I/O端口写数据 |
### 3.2.3 通信总线
用于计算机系统之间或与其他系统之间的通信。
| 类型 | 特点 | 适用距离 |
|------|------|----------|
| 串行通信 | 数据在单条线上逐位传输 | 远距离（可利用电话网络） |
| 并行通信 | 数据在多条线上同时传输 | 近距离（通常<30m） |
```mermaid
graph LR
subgraph "串行通信"
A1[发送端] --> |"1条线<br/>逐位传输"| B1[接收端]
end
subgraph "并行通信"
A2[发送端] --> |"8条线<br/>同时传输"| B2[接收端]
end
```
---
## 3.3 总线特性及性能指标
### 3.3.1 总线特性
| 特性 | 说明 |
|------|------|
| 机械特性 | 尺寸、形状、管脚数、排列顺序 |
| 电气特性 | 传输方向、有效电平范围 |
| 功能特性 | 每根传输线的功能定义 |
| 时间特性 | 信号的时序关系 |
### 3.3.2 总线性能指标
| 指标 | 定义 | 影响因素 |
|------|------|----------|
| 总线宽度 | 数据总线的根数 | 决定一次传输的数据量 |
| 总线带宽 | 单位时间传输数据量 | 总线宽度 × 总线频率 |
| 总线复用 | 地址线与数据线复用 | 减少引脚数，降低效率 |
| 信号线数 | 地址、数据、控制线总数 | 影响接口复杂度 |
| 总线控制方式 | 同步/异步、突发传输等 | 影响传输效率 |
**总线带宽计算**：
$$总线带宽 = \frac{总线宽度}{8} \times 总线频率 \quad (MB/s)$$
> [!example] 示例
> 总线宽度32位，频率66MHz：
> $$带宽 = \frac{32}{8} \times 66 = 264 \quad MB/s$$
---
## 3.4 总线结构
### 3.4.1 单总线结构
所有部件共享同一组总线，结构简单但效率有限。
### 3.4.2 多总线结构
```mermaid
graph TB
subgraph "多总线结构示例"
CPU[CPU] <--> |"前端总线"| NB[北桥]
NB <--> |"存储总线"| MEM[内存]
NB <--> |"PCI总线"| PCI[PCI设备]
PCI <--> |"ISA总线"| ISA[ISA设备]
NB <--> |"AGP总线"| AGP[显卡]
end
style CPU fill:#ff9999
style NB fill:#ffcc00
style MEM fill:#99ff99
```
**优点**：
- 不同速度设备使用不同总线
- 提高整体效率
- 便于扩展
---
## 3.5 总线控制
### 3.5.1 总线判优控制
> [!info] 问题
> 多个部件同时请求总线时，如何决定谁先使用？
#### 集中式仲裁
```mermaid
graph TB
subgraph "集中式仲裁"
BC[总线控制器] --> |"控制信号"| CPU[CPU]
BC --> |"控制信号"| MEM[主存]
BC --> |"控制信号"| IO1[I/O设备1]
BC --> |"控制信号"| IO2[I/O设备2]
end
style BC fill:#ff9999
```
**三种方式**：
| 方式 | 原理 | 优点 | 缺点 |
|------|------|------|------|
| 链式查询 | 依次查询各部件 | 结构简单 | 优先级固定，对故障敏感 |
| 计数器定时查询 | 计数器指定设备号 | 灵活，可编程 | 需要设备地址线 |
| 独立请求方式 | 每个设备有独立请求线 | 响应速度快 | 控制线多，复杂 |
```mermaid
graph TB
subgraph "链式查询"
BG1[总线同意] --> CPU
CPU --> IO1
IO1 --> IO2
IO2 --> ION
BR[总线请求] --> BC[总线控制器]
BS[总线忙] --> BC
end
subgraph "独立请求"
BR1[请求1] --> BC[总线控制器]
BR2[请求2] --> BC
BRN[请求n] --> BC
BG1[同意1] --> CPU
BG2[同意2] --> IO1
BGN[同意n] --> ION
end
```
#### 分布式仲裁
各设备自行判断优先级，无需中央控制器。
### 3.5.2 总线通信控制
> [!info] 目标
> 解决通信双方如何获知传输开始和结束，以及如何协调配合。
#### 四种通信方式
| 方式 | 同步方式 | 特点 | 适用场景 |
|------|----------|------|----------|
| 同步通信 | 统一时钟 | 简单，速度快 | 速度匹配的设备 |
| 异步通信 | 应答信号 | 灵活，可靠 | 速度差异大的设备 |
| 半同步通信 | 时钟+等待 | 兼顾两者 | 中等速度差异 |
| 分离式通信 | 分阶段 | 效率最高 | 高性能系统 |
#### 异步通信的三种类型
```mermaid
sequenceDiagram
participant 主模块
participant 从模块
Note over 主模块,从模块: 不互锁方式
主模块->>从模块: 请求
主模块-->>从模块: (等待固定时间)
从模块->>主模块: 回答
Note over 主模块,从模块: 半互锁方式
主模块->>从模块: 请求
从模块->>主模块: 回答
主模块-->>从模块: (撤销请求)
Note over 主模块,从模块: 全互锁方式
主模块->>从模块: 请求
从模块->>主模块: 回答
主模块->>从模块: 撤销请求
```
---
## 📝 本章小结
### 核心概念
1. **总线定义**：多个部件共享的传输介质
2. **总线分类**：片内总线、系统总线、通信总线
3. **系统总线**：数据总线（双向）、地址总线（单向）、控制总线（总体双向）
4. **总线仲裁**：集中式（链式查询、计数器查询、独立请求）、分布式
5. **通信方式**：同步、异步、半同步、分离式
### 关键公式
- **总线带宽** = 总线宽度/8 × 总线频率
- **地址空间** = $2^n$（n为地址线位数）
### 重点图示
> [!summary] 必须掌握的图
> 1. 三种总线结构框图（面向CPU、单总线、以存储器为中心）
> 2. 总线仲裁方式对比图
> 3. 异步通信三种类型时序图
---
## 🧪 自测练习
### 概念题
1. 什么是总线？为什么需要总线？
2. 比较三种总线结构的优缺点。
3. 说明数据总线、地址总线、控制总线的区别。
### 计算题
1. 某系统总线宽度为32位，总线频率为100MHz，求总线带宽。
2. 若地址线为24位，可寻址多少存储单元？若存储字长为16位，存储容量是多少？
### 分析题
1. 比较三种集中式仲裁方式的优缺点。
2. 说明同步通信和异步通信的区别和适用场景。
---
## 🔗 相关链接
- [[01_计算机系统概论]] - 上一章
- [[04_存储器]] - 下一章
- [[08_CPU结构与功能]] - CPU与总线的连接
---
*本章难度：⭐⭐⭐ 中等*
*重要程度：⭐⭐⭐ 基础*

422
计算机组成原理/学习笔记/03_系统总线_补充版.md Normal file
View File

@@ -0,0 +1,422 @@
# 第3章 系统总线
> 📖 本章介绍系统总线的基本概念、分类和控制逻辑。
> 🎯 重点理解总线结构和总线仲裁方式
---
## 📋 本章目录
- [[#3.1 总线的基本概念]]
- [[#3.2 总线的分类]]
- [[#3.3 总线特性及性能指标]]
- [[#3.4 总线结构]]
- [[#3.5 总线控制]]
- [[#本章小结]]
- [[#例题与解析]]
---
## 3.1 总线的基本概念
### 3.1.1 什么是总线
> [!info] 定义
> 总线是连接多个部件的信息传输线，是各部件**共享**的传输介质。
**关键特性**：
- 同一时刻只允许**一个部件**向总线发送信息
- 多个部件可以**同时**从总线上接收相同的信息
```mermaid
graph TB
subgraph "总线结构"
CPU[CPU] <--> |"共享总线"| BUS[系统总线]
MEM[主存] <--> |"共享总线"| BUS
IO1[I/O设备1] <--> |"共享总线"| BUS
IO2[I/O设备2] <--> |"共享总线"| BUS
IO3[I/O设备3] <--> |"共享总线"| BUS
end
style BUS fill:#ffcc00
```
总线就像一条公共马路：所有车辆（部件）都使用同一条马路，但同一时刻只能过一辆车（单车道），不过一个电台广播时很多人可以同时收听（多人同时接收）。
或者想象一个会议室：麦克风（总线）是共享的，所有人都可以用，但不能两个人同时说话，不过一个人说话时所有人都能听到。
### 3.1.2 总线连接方式
#### 分散连接 vs 总线连接
| 特性 | 分散连接 | 总线连接 |
|------|----------|----------|
| 连线方式 | 各部件单独连线 | 共享传输线 |
| 灵活性 | 差，增删设备困难 | 好，便于扩展 |
| 复杂度 | 高 | 低 |
| 成本 | 高 | 低 |
这两种连接方式可以类比电话系统：分散连接就像每个办公室之间都拉一条专用电话线，A要打给B需要A-B专线，打给C需要A-C专线，线多成本高；总线连接就像所有办公室都连到一条电话总线上，通过总线转接，线少成本低，增加新办公室只需接一条线。
### 3.1.3 总线结构类型
#### 1. 面向CPU的双总线结构
```mermaid
graph TB
subgraph "面向CPU的双总线"
CPU[CPU] <--> |"M总线"| MEM[主存]
CPU <--> |"I/O总线"| IO1[I/O设备1]
CPU <--> |"I/O总线"| IO2[I/O设备2]
CPU <--> |"I/O总线"| ION[I/O设备n]
end
style CPU fill:#ff9999
style MEM fill:#99ff99
```
**特点**：
- 两组总线：M总线（存储总线）和I/O总线
- I/O设备与主存交换信息需经过CPU
- 影响CPU工作效率
这种结构就像公司的物流系统，M总线是仓库和生产车间之间的专用通道，I/O总线是生产车间和客户之间的通道。问题是客户要从仓库取货，必须经过生产车间，影响生产效率。
#### 2. 单总线结构
```mermaid
graph TB
subgraph "单总线结构"
CPU[CPU] <--> |"系统总线"| BUS[系统总线]
MEM[主存] <--> |"系统总线"| BUS
IO1[I/O设备1] <--> |"系统总线"| BUS
IO2[I/O设备2] <--> |"系统总线"| BUS
ION[I/O设备n] <--> |"系统总线"| BUS
end
style BUS fill:#ffcc00
```
**特点**：
- 所有部件挂到同一组总线
- I/O与主存交换信息不占用CPU
- 需要总线判优逻辑解决冲突
单总线就像公司内部只有一条快递通道，所有部门共用。优点是客户可以直接从仓库取货，不经过生产车间；缺点是如果多个部门同时要用通道就会冲突，需要排队。
#### 3. 以存储器为中心的双总线结构
```mermaid
graph TB
subgraph "以存储器为中心的双总线"
CPU[CPU] <--> |"存储总线"| MEM[主存]
MEM <--> |"系统总线"| BUS[系统总线]
IO1[I/O设备1] <--> |"系统总线"| BUS
IO2[I/O设备2] <--> |"系统总线"| BUS
ION[I/O设备n] <--> |"系统总线"| BUS
end
style MEM fill:#99ff99
style BUS fill:#ffcc00
```
**特点**：
- 在单总线基础上增加CPU与主存之间的专用总线
- 存储总线速度高，只供CPU与主存传输信息
- 既提高传输效率，又减轻系统总线负担
这是对单总线的改进，增加了仓库和生产车间之间的高速专用通道。这样既提高了CPU和内存之间的传输效率，其他部门又可以直接从仓库取货，系统总线负担也减轻了。现代计算机大多采用这种结构。
---
## 3.2 总线的分类
### 3.2.1 按连接部件分类
#### 1. 片内总线
> [!info] 定义
> 片内总线是指芯片内部的总线，如在CPU芯片内部，寄存器与寄存器之间、寄存器与算逻单元ALU之间都由片内总线连接。
片内总线就像公司内部各部门之间的内部电话，只在公司内部（芯片内部）使用，用于各部门之间沟通工作，速度快距离短。
#### 2. 系统总线
> [!info] 定义
> 系统总线是指CPU、主存、I/O设备各大部件之间的信息传输线。由于这些部件通常都安放在主板或各个插件板上，故又称板级总线或板间总线。
**系统总线的三类**：
```mermaid
graph TB
subgraph "系统总线"
DB[数据总线] --> |"传输数据"| DATA[数据信息]
AB[地址总线] --> |"传输地址"| ADDR[地址信息]
CB[控制总线] --> |"传输控制"| CTRL[控制信号]
end
```
1. **数据总线**：传输各功能部件之间的数据信息，双向传输，宽度与机器字长有关（8位、16位、32位）
2. **地址总线**：指出源数据或目的数据在主存单元的地址或I/O设备的地址，单向输出（由CPU输出），宽度与存储单元个数有关
3. **控制总线**：发出各种控制信号，每根线单向但整体有输入也有输出，包括存储器读/写、I/O读/写、中断请求等
系统总线可以理解为公司的三套沟通系统：数据总线是快递通道，传送实际的文件和包裹，双向传输；地址总线是门牌号系统，告诉快递员送到哪个办公室，只有总经理（CPU）能指定地址；控制总线是指令系统，传达各种指令和状态，有输入有输出。
当你在电脑上保存文件时：CPU通过地址总线告诉内存"我要存到地址1000"，通过数据总线把文件数据传给内存，通过控制总线发出"写入"命令。
#### 3. 通信总线
> [!info] 定义
> 通信总线用于计算机系统之间或计算机系统与其他系统之间的通信。
**分类**：
1. **串行通信**：数据在单条1位宽的传输线上，一位一位地按顺序传送，适合远距离，成本低，但速度慢
2. **并行通信**：数据在多条并行1位宽的传输线上，同时传送，速度快，但适合近距离，成本高
串行通信就像一个人骑自行车送信，一次只能带一封信，分8次送完8封信，成本低适合远距离；并行通信就像8个人同时骑自行车送信，一次就能送8封信，速度快但成本高。
USB、网络线、电话线用串行通信；打印机接口、早期硬盘接口用并行通信。
---
## 3.3 总线特性及性能指标
### 3.3.1 总线特性
总线特性包括以下几项：
1. **机械特性**：总线在机械连接方式上的一些性能，如插头与插座标准、几何尺寸、引脚个数、排列顺序。就像电源插头的形状和大小。
2. **电气特性**：总线的每一根传输线上信号的传递方向和有效的电平范围，高电平表示1，低电平表示0。就像电源的电压标准（220V还是110V）。
3. **功能特性**：总线中每根传输线的功能，如地址线、数据线、控制线。就像不同颜色的电线代表不同功能。
4. **时间特性**：总线中的任一根线在什么时间内有效，信号时序关系。就像交通信号灯的时序（红灯停、绿灯行）。
### 3.3.2 总线性能指标
| 指标 | 说明 | 计算方式 |
|------|------|----------|
| 总线宽度 | 数据总线的根数 | 8位、16位、32位、64位 |
| 总线带宽 | 数据传输速率 | 总线宽度 × 总线频率 |
| 时钟同步 | 数据与时钟同步方式 | 同步总线、异步总线 |
| 总线复用 | 一条线传送多种信号 | 地址/数据复用 |
| 信号线数 | 三种总线数的总和 | 地址线+数据线+控制线 |
这些指标可以类比公路：总线宽度是车道数，8位就是8车道；总线带宽是车流量，计算方式是车道数×车速；时钟同步就像交通信号灯，同步总线所有车按信号灯行驶；总线复用就像多功能车道，白天走汽车晚上走自行车。
假设总线工作频率为33MHz，总线宽度为32位：总线带宽 = 33MHz × (32÷8) = 132MBps，意味着每秒可以传输132MB的数据。
### 3.3.3 总线标准
> [!info] 定义
> 总线标准是系统与各模块、模块与模块之间的一个互连的标准界面。
总线标准就像交通规则，标准化使得所有车辆都遵守同一套规则，不同品牌的车都能在同一条路上行驶，便于扩展。
常见的总线标准包括ISA、EISA、VESA、PCI、USB等。USB总线是统一的外部设备接口标准，手机、U盘、鼠标都可以用USB接口，不同品牌的设备都能互相兼容，即插即用。
---
## 3.4 总线结构
### 3.4.1 单总线结构
```mermaid
graph TB
subgraph "单总线结构"
CPU[CPU] <--> |"系统总线"| BUS[系统总线]
MEM[主存] <--> |"系统总线"| BUS
IO1[I/O设备1] <--> |"系统总线"| BUS
IO2[I/O设备2] <--> |"系统总线"| BUS
end
style BUS fill:#ffcc00
```
**优点**：结构简单，便于扩展，成本低
**缺点**：总线成为瓶颈，多设备同时使用会冲突，影响系统性能
单总线就像一条单车道公路，建设成本低维护简单，但如果车多就会堵车。早期的个人计算机采用单总线结构。
### 3.4.2 双总线结构
```mermaid
graph TB
subgraph "双总线结构"
CPU[CPU] <--> |"存储总线"| MEM[主存]
CPU <--> |"I/O总线"| IO[I/O设备]
MEM <--> |"I/O总线"| IO
end
style MEM fill:#99ff99
```
**优点**：CPU和I/O可以并行工作，减轻总线负担，提高系统性能
**缺点**：结构复杂，成本高
双总线就像两条公路，存储总线是仓库和生产车间之间的专用高速公路，I/O总线是仓库和其他部门之间的普通公路，专用通道效率高不会互相干扰。现代计算机采用双总线结构。
### 3.4.3 三总线结构
```mermaid
graph TB
subgraph "三总线结构"
CPU[CPU] <--> |"存储总线"| MEM[主存]
CPU <--> |"I/O总线"| IO[I/O设备]
MEM <--> |"DMA总线"| IO
end
style MEM fill:#99ff99
```
**优点**：支持DMA（直接内存访问），I/O设备可以直接访问内存，进一步提高系统性能
三总线增加了仓库和其他部门之间的直达通道（DMA总线），其他部门可以直接从仓库取货，不经过生产车间。现代计算机支持DMA技术，硬盘可以直接把数据传到内存，不经过CPU。
---
## 3.5 总线控制
### 3.5.1 总线仲裁
> [!info] 定义
> 总线仲裁是解决多个部件同时申请使用总线时，如何决定哪个部件获得总线使用权的机制。
**仲裁方式**：
1. **集中式仲裁**：有一个中央仲裁器，控制简单，但有单点故障风险。就像路口的交通警察，指挥统一秩序井然，但如果警察不在交通就乱了。
2. **分布式仲裁**：每个设备都有仲裁逻辑，可靠性高，但控制复杂。就像没有警察，车辆自己按规则（如先到先行）通过，容易混乱但没有单点故障。
传统的电话系统用集中式仲裁，由交换机决定谁先通话；以太网用分布式仲裁，设备自己检测冲突并重试。
### 3.5.2 总线通信控制
**通信方式**：
1. **同步通信**：所有操作按统一时钟进行，控制简单，但速度受限于最慢设备。就像全公司统一上下班时间，管理简单但如果某个部门慢其他部门都要等。
2. **异步通信**：没有统一时钟，用握手信号，速度灵活但控制复杂。就像各部门按自己的节奏工作，用"准备好"和"收到"信号协调，各部门可以按自己的速度工作。
工厂的流水线用同步通信，所有工位按同一节奏工作；快递系统用异步通信，快递员按自己的节奏送货，用"已签收"信号确认。
---
## 📝 本章小结
### 核心概念
1. **总线**：连接多个部件的共享传输介质
2. **总线分类**：片内总线、系统总线、通信总线
3. **总线结构**：单总线、双总线、三总线
4. **总线控制**：仲裁方式、通信控制
### 关键术语
| 术语 | 英文 | 含义 |
|------|------|------|
| Bus | Bus | 总线 |
| Arbitration | Arbitration | 仲裁 |
| Synchronous | Synchronous | 同步 |
| Asynchronous | Asynchronous | 异步 |
| DMA | Direct Memory Access | 直接内存访问 |
### 重点图示
> [!summary] 必须掌握的图
> 1. 三种总线结构框图（单总线、双总线、三总线）
> 2. 系统总线的三类（数据、地址、控制）
> 3. 总线仲裁方式
---
## 🧪 例题与解析
### 例题1：总线带宽计算
**题目**：某计算机总线工作频率为66MHz，总线宽度为32位，求总线带宽。
**答案**：
总线带宽 = 总线频率 × 总线宽度（字节）= 66×10⁶ × 4 = 264×10⁶ 字节/秒 = 264 MBps
这就像一条公路，每秒可以通过66百万辆车，每辆车能装4个包裹（32位=4字节），每秒能送264百万个包裹。
### 例题2：地址总线计算
**题目**：某计算机有20位地址线，求该计算机能访问的最大存储单元数。
**答案**：
20位地址线可以表示 2²⁰ = 1048576 个地址，即能访问1048576个存储单元。
这就像仓库的门牌号系统，20位地址线表示门牌号有20位数字，最多能编1048576个门牌号。
### 例题3：总线结构比较
**题目**：比较单总线结构和双总线结构的优缺点。
**答案**：
单总线结构简单、成本低，但总线成为瓶颈，多设备同时使用会冲突；双总线结构复杂、成本高，但CPU和I/O可以并行工作，总线负担轻，系统性能高。
单总线就像一条主干道，所有车辆都走这条路容易堵车；双总线有两条主干道，一条高速一条普通，车辆分流不容易堵车。
### 例题4：总线仲裁
**题目**：简述集中式仲裁和分布式仲裁的区别。
**答案**：
集中式仲裁有中央仲裁器，控制简单但有单点故障风险；分布式仲裁每个设备都有仲裁逻辑，可靠性高但控制复杂。
集中式仲裁就像路口有警察指挥，秩序井然但警察不在就乱了；分布式仲裁没有警察，车辆自己按规则行驶，没有单点故障但容易混乱。
### 例题5：串行与并行通信
**题目**：比较串行通信和并行通信的优缺点。
**答案**：
串行通信一位一位传送，速度慢但成本低，适合远距离；并行通信多位同时传送，速度快但成本高，适合近距离。
串行通信就像一个人骑自行车送信，成本低适合远距离；并行通信就像8个人同时骑自行车送信，速度快但成本高。
---
## ⚡ 知识点速记卡
> 考前快速过一遍，30秒回忆整章核心
**总线** = 各部件共享的传输介质，同一时刻只能一个部件发送，但多个部件可以同时接收。
**系统总线三类**：数据总线（双向，传数据）、地址总线（单向，CPU输出地址）、控制总线（有读有写，传控制信号）。
**三种总线结构**：单总线（简单但有瓶颈）→ 双总线（CPU-主存专用线+系统总线）→ 三总线（再加DMA总线）。
**总线带宽 = 总线宽度 × 总线频率**。32位宽度、66MHz频率 → 带宽 = 4B × 66M = 264MBps。
**总线仲裁**：集中式（有中央仲裁器，简单但有单点故障）vs 分布式（各设备自己仲裁，可靠但复杂）。
**通信方式**：同步（统一时钟，简单但受限于最慢设备）vs 异步（握手信号，灵活但复杂）。
**串行 vs 并行**：串行一位一位传，慢但便宜适合远距离；并行多位同时传，快但贵适合近距离。
---
## 🔗 相关链接
- [[00_计算机组成原理学习指南]] - 返回主目录
- [[01_计算机系统概论]] - 上一章
- [[04_存储器]] - 下一章
- [[05_输入输出系统]] - I/O相关内容
---
*本章难度：⭐⭐⭐ 中等*
*重要程度：⭐⭐⭐ 基础*

705
计算机组成原理/学习笔记/04_存储器.md Normal file
View File

@@ -0,0 +1,705 @@
# 第4章 存储器
> 📖 本章介绍存储器的分类、工作原理和层次结构，是课程的重点和难点。
> 🎯 重点理解存储层次、主存组成、Cache和虚拟存储器
---
## 📋 本章目录
- [[#4.1 概述]]
- [[#4.2 主存储器]]
- [[#4.3 高速缓冲存储器]]
- [[#4.4 虚拟存储器]]
- [[#本章小结]]
---
## 4.1 概述
### 4.1.1 存储器分类
```mermaid
graph TB
A[存储器分类] --> B[按存储介质]
A --> C[按存取方式]
A --> D[按作用]
B --> B1[半导体存储器]
B --> B2[磁表面存储器]
B --> B3[光盘存储器]
C --> C1[随机存储器RAM]
C --> C2[只读存储器ROM]
C --> C3[串行访问存储器]
D --> D1[主存储器]
D --> D2[辅助存储器]
D --> D3[缓冲存储器Cache]
```
#### 按存储介质分类
| 类型 | 特点 | 示例 |
|------|------|------|
| 半导体存储器 | 体积小、功耗低、速度快、易失性 | SRAM、DRAM |
| 磁表面存储器 | 非易失、容量大、速度慢 | 磁盘、磁带 |
| 光盘存储器 | 非易失、容量大、可移动 | CD、DVD |
#### 按存取方式分类
| 类型 | 特点 | 应用 |
|------|------|------|
| **RAM** | 随机读写、存取时间与位置无关 | 主存 |
| **ROM** | 只读不写（或受限写入） | 固件、BIOS |
| **顺序存取** | 按物理顺序寻找（如磁带） | 磁带 |
| **直接存取** | 先直接定位区域，再顺序寻找（如磁盘） | 磁盘 |
#### RAM和ROM的细分
```mermaid
graph LR
RAM[随机存储器RAM] --> SRAM[静态RAM<br/>触发器原理]
RAM --> DRAM[动态RAM<br/>电容充放电]
ROM[只读存储器ROM] --> MROM[掩模ROM]
ROM --> PROM[可编程ROM]
ROM --> EPROM[可擦除PROM]
ROM --> EEPROM[电擦除PROM]
ROM --> Flash[闪速存储器]
```
### 4.1.2 存储器的层次结构
> [!important] 核心问题
> 速度、容量、价格三者不可兼得，需要通过层次结构解决矛盾。
#### 存储器性能指标关系
```mermaid
graph TB
subgraph "存储器层次结构"
REG["寄存器<br/>速度最快、容量最小、价格最高"] --> CACHE["Cache<br/>高速缓冲存储器"]
CACHE --> MEM["主存储器<br/>主存"]
MEM --> DISK["磁盘<br/>辅助存储器"]
DISK --> TAPE["磁带<br/>辅助存储器"]
end
style REG fill:#ff9999
style CACHE fill:#ffcc99
style MEM fill:#ffff99
style DISK fill:#99ff99
style TAPE fill:#9999ff
```
| 层次 | 速度 | 容量 | 价格 | 位置 |
|------|------|------|------|------|
| 寄存器 | 最快 | 最小 | 最高 | CPU内部 |
| Cache | 很快 | 小 | 高 | CPU内部/外部 |
| 主存 | 较快 | 中等 | 中等 | 主板 |
| 磁盘 | 慢 | 大 | 低 | 外部设备 |
| 磁带 | 最慢 | 最大 | 最低 | 外部设备 |
#### 两个存储层次
```mermaid
graph TB
subgraph "缓存-主存层次"
CPU1[CPU] <--> |"速度接近Cache"| CACHE[Cache]
CACHE <--> |"容量接近主存"| MEM1[主存]
end
subgraph "主存-辅存层次"
MEM2[主存] <--> |"速度接近主存"| DISK[辅存]
CPU2[CPU] -.-> |"不直接访问"| DISK
end
style CPU1 fill:#ff9999
style CPU2 fill:#ff9999
style CACHE fill:#ffcc99
style MEM1 fill:#ffff99
style MEM2 fill:#ffff99
style DISK fill:#99ff99
```
**缓存-主存层次**：
- 解决CPU和主存**速度不匹配**问题
- 数据调动由**硬件**自动完成
- 对程序员**透明**
**主存-辅存层次**：
- 解决存储系统**容量**问题
- 数据调动由**硬件+操作系统**完成
- 对程序员**透明**
---
## 4.2 主存储器
### 4.2.1 主存的基本组成
```mermaid
graph TB
subgraph "主存结构"
MAR[MAR<br/>地址寄存器] --> |"地址"| DEC[译码器]
DEC --> |"选择信号"| MEM[存储体]
MEM <--> |"数据"| MDR[MDR<br/>数据寄存器]
MDR <--> |"数据"| DBUS[数据总线]
MAR <--> |"地址"| ABUS[地址总线]
CTRL[控制电路] --> |"读写控制"| MEM
end
style MAR fill:#ff9999
style MDR fill:#99ccff
style MEM fill:#99ff99
style DEC fill:#ffcc99
```
**工作过程**：
1. **读操作**：CPU将地址送MAR → 地址总线 → 译码器选中单元 → 读出数据到MDR → 数据总线
2. **写操作**：CPU将地址送MAR，数据送MDR → 发写命令 → 数据写入选中单元
### 4.2.2 主存中存储单元地址的分配
#### 字节寻址与字寻址
```mermaid
graph TB
subgraph "IBM 370（32位字长）"
A1["地址0"] --> B1["字节0"]
A2["地址1"] --> B2["字节1"]
A3["地址2"] --> B3["字节2"]
A4["地址3"] --> B4["字节3"]
A5["地址4（字地址）"] --> B5["下一个字"]
end
subgraph "PDP-11（16位字长）"
C1["地址0（字地址）"] --> D1["字节0"]
C2["地址1"] --> D2["字节1"]
C3["地址2（字地址）"] --> D3["下一个字"]
end
```
> [!note] 地址表示
> - IBM 370：字地址 = 高位字节地址（4的倍数）
> - PDP-11：字地址 = 低位字节地址（2的倍数）
### 4.2.3 主存的技术指标
#### 1. 存储容量
$$存储容量 = 存储单元个数 \times 存储字长$$
**字节表示**：
$$存储容量 = 存储单元个数 \times 存储字长 / 8$$
> [!example] 示例
> 24位地址线，按字节寻址：
> - 寻址范围：$2^{24} = 16M$ 个字节
> - 若字长32位：按字寻址范围 = $16M / 4 = 4M$ 个字
#### 2. 存储速度
| 指标 | 定义 | 关系 |
|------|------|------|
| **存取时间** | 启动一次操作到完成的时间 | 读出时间或写入时间 |
| **存取周期** | 连续两次操作的最小间隔 | 存取周期 > 存取时间 |
| **存储器带宽** | 单位时间存取信息量 | 带宽 = 存储字长 / 存取周期 |
**提高带宽的措施**：
1. 缩短存取周期
2. 增加存储字长
3. 增加存储体
### 4.2.4 半导体存储芯片
#### 芯片基本结构
```mermaid
graph LR
subgraph "存储芯片"
ADDR[地址线] --> DEC[译码驱动]
DEC --> MEM[存储矩阵]
MEM <--> RW[读/写电路]
RW <--> DATA[数据线]
CS[片选线] --> DEC
RW_CTRL[读写控制线] --> RW
end
```
**容量计算**：
$$芯片容量 = 2^{地址线位数} \times 数据线位数$$
> [!example] 示例
> - 10根地址线，4根数据线：$2^{10} \times 4 = 4K$ 位
> - 14根地址线，1根数据线：$2^{14} \times 1 = 16K$ 位
#### 译码驱动方式
| 方式 | 特点 | 适用场景 |
|------|------|----------|
| **线选法** | 一根字线直接选中一个单元 | 容量小的芯片 |
| **重合法** | X、Y两个方向译码，交叉点选中 | 大容量芯片 |
```mermaid
graph TB
subgraph "线选法（16×1字节）"
A1["A3A2A1A0 = 1111"] --> B1["第15根字线选中"]
B1 --> C1["8位数据读出"]
end
subgraph "重合法（1K×1位）"
A2["地址译码"] --> B2["X方向32根线"]
A2 --> C2["Y方向32根线"]
B2 --> D2["交叉点选中1位"]
C2 --> D2
end
```
### 4.2.5 随机存取存储器（RAM）
#### 静态RAM（SRAM）
**基本单元电路**：6个MOS管组成的触发器
**特点**：
- 用触发器原理寄存信息
- 速度快，不需要刷新
- 集成度低，功耗大
- 用于Cache
**典型芯片**：Intel 2114（1K×4位）
#### 动态RAM（DRAM）
**基本单元电路**：1个MOS管 + 电容
**特点**：
- 用电容充放电原理寄存信息
- 需要定期**刷新**
- 集成度高，功耗小
- 用于主存
**典型芯片**：Intel 4116（16K×1位）
**刷新方式**：
| 方式 | 特点 | 效率 |
|------|------|------|
| 集中刷新 | 一段时间集中刷新所有行 | 有死区 |
| 分散刷新 | 每行刷新分散到各周期 | 无死区，效率低 |
| 异步刷新 | 各行刷新均匀分散 | 折中方案 |
#### SRAM vs DRAM 对比
| 特性 | SRAM | DRAM |
|------|------|------|
| 存储原理 | 触发器 | 电容 |
| 速度 | 快 | 较慢 |
| 集成度 | 低 | 高 |
| 功耗 | 大 | 小 |
| 刷新 | 不需要 | 需要 |
| 价格 | 高 | 低 |
| 应用 | Cache | 主存 |
### 4.2.6 只读存储器（ROM）
| 类型 | 特点 | 应用 |
|------|------|------|
| **MROM** | 厂家掩模制作，不可更改 | 批量生产 |
| **PROM** | 用户可编程一次 | 小批量 |
| **EPROM** | 紫外线擦除，可重复编程 | 开发调试 |
| **EEPROM** | 电擦除，可重复编程 | 参数存储 |
| **Flash** | 电擦除，速度快 | U盘、SSD |
### 4.2.7 存储器与CPU的连接
#### 存储器容量扩展
**三种扩展方式**：
```mermaid
graph TB
subgraph "位扩展"
A1["芯片1（8位）"] --> C1["组合（16位）"]
A2["芯片2（8位）"] --> C1
end
subgraph "字扩展"
B1["芯片1（1K×8）"] --> D1["组合（2K×8）"]
B2["芯片2（1K×8）"] --> D1
end
subgraph "字位同时扩展"
E1["芯片1"] --> F1["组合"]
E2["芯片2"] --> F1
E3["芯片3"] --> F1
E4["芯片4"] --> F1
end
```
| 扩展方式 | 连接方法 | 应用场景 |
|----------|----------|----------|
| **位扩展** | 地址线、控制线并联，数据线串联 | 增加字长 |
| **字扩展** | 地址线、数据线、控制线并联，片选线用高位地址 | 增加字数 |
| **字位扩展** | 先位扩展，再字扩展 | 大容量存储器 |
#### 存储器与CPU连接示例
```mermaid
graph TB
subgraph "CPU"
MAR[MAR] --> |"地址"| ADDR[地址总线]
MDR[MDR] <--> |"数据"| DATA[数据总线]
CTRL[控制信号] --> |"读写"| RW[读写控制]
end
subgraph "存储器"
ADDR --> |"地址"| CHIP1[芯片1]
ADDR --> |"地址"| CHIP2[芯片2]
CHIP1 <--> |"数据"| DATA
CHIP2 <--> |"数据"| DATA
CS1[片选1] --> CHIP1
CS2[片选2] --> CHIP2
RW --> CHIP1
RW --> CHIP2
end
```
### 4.2.8 存储器的校验
#### 奇偶校验
**原理**：增加1位校验位，使数据中1的个数为奇数（奇校验）或偶数（偶校验）。
**特点**：
- 简单，只能检测奇数位错误
- 不能纠错
#### 海明码（Hamming Code）
**原理**：在数据位中插入多个校验位，通过校验位的组合定位错误位。
**校验位数r满足**：$2^r \geq m + r + 1$（m为数据位数）
**特点**：
- 可以检测并纠正1位错误
- 可以检测2位错误
> [!example] 示例
> 8位数据需要4位校验码：
> - 总位数：8 + 4 = 12位
> - 校验位位置：1, 2, 4, 8
> - 可纠正1位错误
---
## 4.3 高速缓冲存储器（Cache）
### 4.3.1 Cache的基本原理
> [!important] 为什么需要Cache
> CPU速度远快于主存，Cache作为中间缓冲，解决速度不匹配问题。
```mermaid
graph LR
CPU[CPU] <--> |"速度匹配"| CACHE[Cache]
CACHE <--> |"容量大"| MEM[主存]
style CPU fill:#ff9999
style CACHE fill:#ffcc99
style MEM fill:#99ff99
```
**工作原理**：
1. CPU访问数据时，先查Cache
2. **命中**：直接从Cache读取（快）
3. **未命中**：从主存读取，同时调入Cache
### 4.3.2 Cache命中率
**命中率**：
$$H = \frac{N_c}{N_c + N_m}$$
- $N_c$：Cache访问次数
- $N_m$：主存访问次数
**平均访问时间**：
$$T_a = HT_c + (1-H)T_m$$
**访问效率**：
$$e = \frac{T_c}{T_a} = \frac{1}{H + (1-H)r}$$
其中 $r = T_m / T_c$（主存与Cache访问时间之比）
> [!example] 示例
> Cache命中率95%，Cache访问时间10ns，主存访问时间100ns：
> $$T_a = 0.95 \times 10 + 0.05 \times 100 = 14.5ns$$
> $$e = \frac{10}{14.5} = 69\%$$
### 4.3.3 Cache地址映射
> [!info] 问题
> 主存块如何放入Cache？需要地址映射。
#### 三种映射方式
##### 1. 直接映射（Direct Mapping）
**规则**：每个主存块只能映射到Cache的固定行。
**映射公式**：$i = j \mod m$
- i：Cache行号
- j：主存块号
- m：Cache行数
```mermaid
graph LR
subgraph "直接映射"
M0[主存块0] --> C0[Cache行0]
M1[主存块1] --> C1[Cache行1]
Mm[主存块m] --> Cm[Cache行m]
Mm1[主存块m+1] --> C0
end
```
**地址结构**：
| 标记（Tag） | Cache行号（Index） | 块内地址（Offset） |
|-------------|-------------------|-------------------|
**优点**：实现简单，查找速度快
**缺点**：灵活性差，命中率低
##### 2. 全相联映射（Fully Associative Mapping）
**规则**：主存块可以映射到Cache的任意行。
```mermaid
graph LR
subgraph "全相联映射"
M0[主存块0] --> |"任意行"| CACHE[Cache]
M1[主存块1] --> |"任意行"| CACHE
Mn[主存块n] --> |"任意行"| CACHE
end
```
**地址结构**：
| 标记（Tag） | 块内地址（Offset） |
|-------------|-------------------|
**优点**：灵活性好，命中率高
**缺点**：查找速度慢，硬件成本高
##### 3. 组相联映射（Set Associative Mapping）
**规则**：将Cache分组，主存块映射到固定组，组内任意行。
**映射公式**：$q = j \mod u$
- q：Cache组号
- j：主存块号
- u：Cache组数
```mermaid
graph LR
subgraph "组相联映射"
M0[主存块0] --> G0[Cache组0]
M1[主存块1] --> G1[Cache组1]
Mu[主存块u] --> Gu[Cache组u]
Mu1[主存块u+1] --> G0
end
```
**地址结构**：
| 标记（Tag） | 组号（Index） | 块内地址（Offset） |
|-------------|--------------|-------------------|
**优点**：折中方案，兼顾速度和命中率
**应用**：现代Cache常用2路、4路、8路组相联
#### 三种映射方式对比
| 方式 | 映射规则 | 灵活性 | 命中率 | 硬件复杂度 |
|------|----------|--------|--------|------------|
| 直接映射 | 固定行 | 差 | 低 | 简单 |
| 全相联映射 | 任意行 | 好 | 高 | 复杂 |
| 组相联映射 | 固定组，任意行 | 中 | 中 | 中等 |
### 4.3.4 Cache替换算法
> [!info] 问题
> Cache满时，新块调入需要替换旧块，如何选择？
#### 常用替换算法
| 算法 | 原则 | 优点 | 缺点 |
|------|------|------|------|
| **FIFO** | 先进先出 | 实现简单 | 不考虑访问频率 |
| **LRU** | 最近最少使用 | 命中率高 | 实现复杂 |
| **LFU** | 最不经常使用 | 考虑频率 | 需要计数器 |
| **随机替换** | 随机选择 | 实现简单 | 命中率不稳定 |
**LRU算法实现**：
- 为每行设置计数器
- 每次访问，命中行计数器清零，其他行加1
- 替换计数器值最大的行
### 4.3.5 Cache写策略
> [!info] 问题
> Cache数据修改后，如何与主存保持一致？
#### 写策略
| 策略 | 方法 | 优点 | 缺点 |
|------|------|------|------|
| **写直达** | 同时写Cache和主存 | 数据一致性好 | 速度慢 |
| **写回法** | 只写Cache，替换时写回主存 | 速度快 | 数据可能不一致 |
```mermaid
graph TB
subgraph "写直达"
CPU1[CPU] --> |"写"| CACHE1[Cache]
CPU1 --> |"同时写"| MEM1[主存]
end
subgraph "写回法"
CPU2[CPU] --> |"写"| CACHE2[Cache]
CACHE2 --> |"替换时写回"| MEM2[主存]
end
```
### 4.3.6 Cache性能分析
**加速比**：
$$加速比 = \frac{T_m}{T_a} = \frac{r}{1 + (r-1)H}$$
**Cache容量选择**：
- 太小：命中率低
- 太大：成本高，速度可能下降
- 通常：几十KB到几MB
---
## 4.4 虚拟存储器
### 4.4.1 虚拟存储器的概念
> [!info] 定义
> 虚拟存储器是一个逻辑模型，程序员看到的地址空间远大于实际主存。
**特点**：
- **虚拟地址**（逻辑地址）：程序员使用的地址
- **物理地址**（实地址）：主存实际地址
- 地址转换由硬件和OS自动完成
```mermaid
graph TB
subgraph "虚拟存储器"
VA[虚拟地址空间<br/>很大] --> |"地址转换"| PA[物理地址空间<br/>较小]
PA --> MEM[主存]
MEM --> DISK[辅存]
end
```
### 4.4.2 页式虚拟存储器
**基本思想**：
- 虚拟地址空间划分为固定大小的**页**
- 主存划分为相同大小的**页框**
- 通过**页表**建立映射关系
**地址结构**：
| 虚页号 | 页内地址 |
|--------|----------|
**页表项**：
| 虚页号 | 实页号 | 有效位 | 修改位 |
|--------|--------|--------|--------|
**地址转换过程**：
1. 从虚拟地址取出虚页号
2. 查页表得到实页号
3. 实页号 + 页内地址 = 物理地址
### 4.4.3 TLB（快表）
> [!info] 问题
> 页表在主存中，每次访问都要查页表，速度慢。
**解决方案**：在CPU中设置TLB（Translation Lookaside Buffer）
**特点**：
- 高速小容量存储器
- 存放最近使用的页表项
- 命中率通常 > 99%
**访问流程**：
1. 先查TLB
2. **TLB命中**：直接得到物理地址（快）
3. **TLB未命中**：查页表，更新TLB
---
## 📝 本章小结
### 核心概念
1. **存储层次**：寄存器 → Cache → 主存 → 辅存
2. **主存组成**：存储体 + MAR + MDR + 译码驱动 + 读写电路
3. **RAM分类**：SRAM（快，用于Cache）、DRAM（慢，用于主存）
4. **Cache映射**：直接映射、全相联映射、组相联映射
5. **虚拟存储器**：虚拟地址 → 物理地址的转换
### 关键公式
- **存储容量** = 存储单元个数 × 存储字长
- **Cache命中率** $H = N_c / (N_c + N_m)$
- **平均访问时间** $T_a = HT_c + (1-H)T_m$
- **访问效率** $e = T_c / T_a$
### 重点图示
> [!summary] 必须掌握的图
> 1. 存储器层次结构图
> 2. 主存基本组成框图
> 3. Cache三种映射方式示意图
> 4. Cache访问流程图
---
## 🧪 自测练习
### 概念题
1. 说明存储器层次结构的必要性。
2. 比较SRAM和DRAM的特点。
3. 解释Cache三种映射方式的区别。
### 计算题
1. 某系统Cache命中率90%，Cache访问时间20ns，主存访问时间200ns，求平均访问时间和访问效率。
2. 24位地址线，按字节寻址，存储字长32位，求存储容量。
### 分析题
1. 设计一个16K×8位的存储器，使用4K×4位的芯片。
2. 说明Cache写策略的选择依据。
---
## 🔗 相关链接
- [[03_系统总线]] - 上一章
- [[05_输入输出系统]] - 下一章
- [[08_CPU结构与功能]] - CPU访问存储器
- [[06_运算方法]] - 数据表示
---
*本章难度：⭐⭐⭐⭐⭐ 困难*
*重要程度：⭐⭐⭐⭐⭐ 核心重点*

682
计算机组成原理/学习笔记/04_存储器_补充版.md Normal file
View File

@@ -0,0 +1,682 @@
# 第4章 存储器
> 📖 本章介绍存储器的分类、工作原理和层次结构，是课程的重点和难点。
> 🎯 重点理解存储层次、主存组成、Cache和虚拟存储器
---
## 📋 本章目录
- [[#4.1 概述]]
- [[#4.2 主存储器]]
- [[#4.3 高速缓冲存储器（Cache）]]
- [[#4.4 虚拟存储器]]
- [[#本章小结]]
- [[#例题与解析]]
---
## 4.1 概述
### 4.1.1 存储器分类
```mermaid
graph TB
A[存储器分类] --> B[按存储介质]
A --> C[按存取方式]
A --> D[按作用]
B --> B1[半导体存储器]
B --> B2[磁表面存储器]
B --> B3[光盘存储器]
C --> C1[随机存储器RAM]
C --> C2[只读存储器ROM]
C --> C3[串行访问存储器]
D --> D1[主存储器]
D --> D2[辅助存储器]
D --> D3[缓冲存储器Cache]
```
#### 按存储介质分类
| 类型 | 特点 | 示例 |
|------|------|------|
| 半导体存储器 | 体积小、功耗低、速度快、易失性 | SRAM、DRAM |
| 磁表面存储器 | 非易失、容量大、速度慢 | 磁盘、磁带 |
| 光盘存储器 | 非易失、容量大、可移动 | CD、DVD |
半导体存储器就像办公室的便签纸，写得快但关灯（断电）就没了，比如内存条、Cache；磁表面存储器像记事本，写得慢但关灯还在，比如机械硬盘、磁带；光盘存储器像刻在石头上的字，只能读不能改或改起来麻烦，比如CD、DVD。
#### 按存取方式分类
| 类型 | 特点 | 应用 |
|------|------|------|
| **RAM** | 随机读写、存取时间与位置无关 | 主存 |
| **ROM** | 只读不写（或受限写入） | 固件、BIOS |
| **顺序存取** | 按物理顺序寻找（如磁带） | 磁带 |
| **直接存取** | 先直接定位区域，再顺序寻找（如磁盘） | 磁盘 |
RAM就像图书馆的书架，可以直接走到任何一本书前，找任何一本书的时间都一样；ROM像图书馆的珍本室，只能看不能改；顺序存取像听磁带，要听第5首歌必须快进到第5首；直接存取像唱片，先移动唱针到大致位置，再慢慢找精确位置。
#### RAM和ROM的细分
```mermaid
graph LR
RAM[随机存储器RAM] --> SRAM[静态RAM<br/>触发器原理]
RAM --> DRAM[动态RAM<br/>电容充放电]
ROM[只读存储器ROM] --> MROM[掩模ROM]
ROM --> PROM[可编程ROM]
ROM --> EPROM[可擦除PROM]
ROM --> EEPROM[电擦除PROM]
ROM --> Flash[闪速存储器]
```
SRAM用两个互锁的开关存储信息，速度快不需要刷新，但体积大功耗高，用于CPU的Cache；DRAM用电容存储电荷，需要定期刷新（就像漏水的桶需要不断加水），但体积小功耗低，用于电脑的内存条。
ROM家族中，MROM出厂时就写好了不能改，像印刷好的书；PROM用户可以写一次，像一次性写入的光盘；EPROM用紫外线擦除可以重写，像用铅笔写的字可以用橡皮擦掉；EEPROM用电擦除更方便；Flash电擦除速度快容量大，用于U盘、SSD。
### 4.1.2 存储器的层次结构
> [!important] 核心问题
> 速度、容量、价格三者不可兼得，需要通过层次结构解决矛盾。
```mermaid
graph TB
subgraph "存储器层次结构"
REG["寄存器<br/>速度最快、容量最小、价格最高"] --> CACHE["Cache<br/>高速缓冲存储器"]
CACHE --> MEM["主存储器<br/>主存"]
MEM --> DISK["磁盘<br/>辅助存储器"]
DISK --> TAPE["磁带<br/>辅助存储器"]
end
style REG fill:#ff9999
style CACHE fill:#ffcc99
style MEM fill:#ffff99
style DISK fill:#99ff99
style TAPE fill:#9999ff
```
| 层次 | 速度 | 容量 | 价格 | 位置 |
|------|------|------|------|------|
| 寄存器 | 最快 | 最小 | 最高 | CPU内部 |
| Cache | 很快 | 小 | 高 | CPU内部/外部 |
| 主存 | 较快 | 中等 | 中等 | 主板 |
| 磁盘 | 慢 | 大 | 低 | 外部设备 |
| 磁带 | 最慢 | 最大 | 最低 | 外部设备 |
这个层次结构可以理解为公司的文件管理系统：寄存器是办公桌上的便签，伸手就能拿到但只能放几张；Cache是办公桌抽屉，拉开就能拿到但容量有限；主存是办公室的文件柜，要站起来走到文件柜前；磁盘是公司的档案室，要走到档案室；磁带是公司的地下室仓库，走得最远但容量最大。
#### 两个存储层次
```mermaid
graph TB
subgraph "缓存-主存层次"
CPU1[CPU] <--> |"速度接近Cache"| CACHE[Cache]
CACHE <--> |"容量接近主存"| MEM1[主存]
end
subgraph "主存-辅存层次"
MEM2[主存] <--> |"速度接近主存"| DISK[辅存]
CPU2[CPU] -.-> |"不直接访问"| DISK
end
style CPU1 fill:#ff9999
style CPU2 fill:#ff9999
style CACHE fill:#ffcc99
style MEM1 fill:#ffff99
style MEM2 fill:#ffff99
style DISK fill:#99ff99
```
**缓存-主存层次**解决CPU和主存速度不匹配问题，数据调动由硬件自动完成，对程序员透明。就像在办公桌上放一个常用文件架，找文件时先看文件架上有没有，有就直接拿，没有就去文件柜拿同时放到文件架上。
**主存-辅存层次**解决存储系统容量问题，数据调动由硬件+操作系统完成，对程序员透明。就像把不常用的文件放到档案室，需要时再取，办公室空间小档案室空间大。
---
## 4.2 主存储器
### 4.2.1 主存的基本组成
```mermaid
graph TB
subgraph "主存结构"
MAR[MAR<br/>地址寄存器] --> |"地址"| DEC[译码器]
DEC --> |"选择信号"| MEM[存储体]
MEM <--> |"数据"| MDR[MDR<br/>数据寄存器]
MDR <--> |"数据"| DBUS[数据总线]
MAR <--> |"地址"| ABUS[地址总线]
CTRL[控制电路] --> |"读写控制"| MEM
end
style MAR fill:#ff9999
style MDR fill:#99ccff
style MEM fill:#99ff99
style DEC fill:#ffcc99
```
**工作过程**：
1. **读操作**：CPU将地址送MAR → 地址总线 → 译码器选中单元 → 读出数据到MDR → 数据总线
2. **写操作**：CPU将地址送MAR，数据送MDR → 发写命令 → 数据写入选中单元
主存就像一个巨大的图书馆：MAR（地址寄存器）记住你要找哪本书的书号；译码器根据书号找到对应的书架；存储体是存放所有书籍的书架；MDR（数据寄存器）暂时存放找到的书；控制电路控制是借书（读）还是还书（写）。
当你从内存地址1000读取数据时：CPU把地址1000放到MAR中，MAR通过地址总线把1000传给译码器，译码器找到地址1000对应的存储单元，存储单元的数据读出到MDR，MDR通过数据总线把数据传给CPU。
### 4.2.2 主存中存储单元地址的分配
```mermaid
graph TB
subgraph "IBM 370（32位字长）"
A1["地址0"] --> B1["字节0"]
A2["地址1"] --> B2["字节1"]
A3["地址2"] --> B3["字节2"]
A4["地址3"] --> B4["字节3"]
A5["地址4（字地址）"] --> B5["下一个字"]
end
subgraph "PDP-11（16位字长）"
C1["地址0（字地址）"] --> D1["字节0"]
C2["地址1"] --> D2["字节1"]
C3["地址2（字地址）"] --> D3["下一个字"]
end
```
> [!note] 地址表示
> - IBM 370：字地址 = 高位字节地址（4的倍数）
> - PDP-11：字地址 = 低位字节地址（2的倍数）
这就像仓库有两种编号方式：IBM 370中，每个小格子都有独立编号，每4个小格子组成一个大格子，大格子的编号是第一个小格子的编号；PDP-11中，每2个小格子组成一个大格子。
### 4.2.3 主存的技术指标
#### 1. 存储容量
$$存储容量 = 存储单元个数 \times 存储字长$$
**字节表示**：
$$存储容量 = 存储单元个数 \times 存储字长 / 8$$
> [!example] 示例
> 24位地址线，按字节寻址：
> - 寻址范围：$2^{24} = 16M$ 个字节
> - 若字长32位：按字寻址范围 = $16M / 4 = 4M$ 个字
存储容量就像仓库的大小，存储单元个数是仓库有多少个格子，存储字长是每个格子能放多少东西。假设一个仓库有1024个格子，每个格子能放8个鸡蛋，总容量就是1024×8=8192个鸡蛋=1KB。
#### 2. 存储速度
| 指标 | 定义 | 关系 |
|------|------|------|
| **存取时间** | 启动一次操作到完成的时间 | 读出时间或写入时间 |
| **存取周期** | 连续两次操作的最小间隔 | 存取周期 > 存取时间 |
| **存储器带宽** | 单位时间存取信息量 | 带宽 = 存储字长 / 存取周期 |
存取时间就像从你要一本书到拿到书的时间；存取周期是连续两次取书的最小间隔，比存取时间长因为管理员需要休息；存储器带宽是单位时间能取多少本书。
假设存储字长为32位（4字节），存取周期为100ns：带宽 = 32位/100ns = 4字节/100ns = 40MBps。
### 4.2.4 半导体存储芯片
```mermaid
graph LR
subgraph "存储芯片"
ADDR[地址线] --> DEC[译码驱动]
DEC --> MEM[存储矩阵]
MEM <--> RW[读/写电路]
RW <--> DATA[数据线]
CS[片选线] --> DEC
RW_CTRL[读写控制线] --> RW
end
```
**容量计算**：
$$芯片容量 = 2^{地址线位数} \times 数据线位数$$
存储芯片就像一个小型仓库：地址线告诉仓库你要哪个格子的东西，数据线传送你拿到的东西，译码驱动根据地址找到对应的格子，存储矩阵是存放所有东西的格子，读/写电路控制是取东西还是放东西，片选线选择是哪个仓库。
一个存储芯片有10根地址线和4根数据线：容量 = 2¹⁰ × 4 = 1024 × 4 = 4096位 = 512字节。
#### 译码驱动方式
| 方式 | 特点 | 适用场景 |
|------|------|----------|
| **线选法** | 一根字线直接选中一个单元 | 容量小的芯片 |
| **重合法** | X、Y两个方向译码，交叉点选中 | 大容量芯片 |
线选法就像图书馆的书架，每个格子都有独立的编号，你说要第15本书，管理员直接走到第15个格子；重合法就像电影院的座位，用行号和列号定位，你说要第3排第5个座位，管理员先找第3排再找第5个。
16个格子用线选法需要16根选择线；1024个格子用重合法只需要64根线（32根X方向+32根Y方向）。
### 4.2.5 随机存取存储器（RAM）
#### 静态RAM（SRAM）
**基本单元电路**：6个MOS管组成的触发器
**特点**：
- 用触发器原理寄存信息
- 速度快，不需要刷新
- 集成度低，功耗大
- 用于Cache
SRAM就像一个稳定的开关，用两个互锁的开关存储信息，状态改变很快且稳定，不需要刷新，但每个存储单元需要6个晶体管体积大。CPU的L1、L2、L3 Cache通常使用SRAM。
#### 动态RAM（DRAM）
**基本单元电路**：1个MOS管 + 电容
**特点**：
- 用电容充放电原理寄存信息
- 需要定期**刷新**
- 集成度高，功耗小
- 用于主存
DRAM就像一个漏水的桶，用电容存储电荷表示0和1，但电容会漏电需要定期补充（刷新），每个存储单元只需要1个晶体管和1个电容体积小。电脑的8GB内存条通常使用DRAM。
**刷新方式**：
| 方式 | 特点 | 效率 |
|------|------|------|
| 集中刷新 | 一段时间集中刷新所有行 | 有死区 |
| 分散刷新 | 每行刷新分散到各周期 | 无死区，效率低 |
| 异步刷新 | 各行刷新均匀分散 | 折中方案 |
集中刷新就像每隔一段时间暂停所有工作集中给所有桶加水，有死区；分散刷新每次取水后顺便给这个桶加点水，没有死区但效率低；异步刷新把加水任务均匀分配到各个时间段，没有死区效率较高。
#### SRAM vs DRAM 对比
| 特性 | SRAM | DRAM |
|------|------|------|
| 存储原理 | 触发器 | 电容 |
| 速度 | 快 | 较慢 |
| 集成度 | 低 | 高 |
| 功耗 | 大 | 小 |
| 刷新 | 不需要 | 需要 |
| 价格 | 高 | 低 |
| 应用 | Cache | 主存 |
SRAM像高级记事本，用特殊墨水写上就不掉，写得快不用维护但贵容量小，用于记录重要信息（Cache）；DRAM像普通记事本，用铅笔写容易掉，写得较慢需要经常描但便宜容量大，用于记录一般信息（主存）。
### 4.2.6 只读存储器（ROM）
| 类型 | 特点 | 应用 |
|------|------|------|
| **MROM** | 厂家掩模制作，不可更改 | 批量生产 |
| **PROM** | 用户可编程一次 | 小批量 |
| **EPROM** | 紫外线擦除，可重复编程 | 开发调试 |
| **EEPROM** | 电擦除，可重复编程 | 参数存储 |
| **Flash** | 电擦除，速度快 | U盘、SSD |
MROM像印刷好的书，出厂时就印好了不能改，成本低适合批量生产；PROM像一次性写入的光盘，用户可以写一次但不能改；EPROM像用铅笔写的书，可以用橡皮擦掉重写；EEPROM用电子橡皮擦更方便；Flash是高速电子橡皮擦，又快又大。
### 4.2.7 存储器与CPU的连接
#### 存储器容量扩展
**三种扩展方式**：
```mermaid
graph TB
subgraph "位扩展"
A1["芯片1（8位）"] --> C1["组合（16位）"]
A2["芯片2（8位）"] --> C1
end
subgraph "字扩展"
B1["芯片1（1K×8）"] --> D1["组合（2K×8）"]
B2["芯片2（1K×8）"] --> D1
end
subgraph "字位同时扩展"
E1["芯片1"] --> F1["组合"]
E2["芯片2"] --> F1
E3["芯片3"] --> F1
E4["芯片4"] --> F1
end
```
| 扩展方式 | 连接方法 | 应用场景 |
|----------|----------|----------|
| **位扩展** | 地址线、控制线并联，数据线串联 | 增加字长 |
| **字扩展** | 地址线、数据线、控制线并联，片选线用高位地址 | 增加字数 |
| **字位扩展** | 先位扩展，再字扩展 | 大容量存储器 |
位扩展就像把两个小盒子并排增加每个格子的容量，两个8位的芯片合并成16位；字扩展就像增加更多的格子，两个1K×8的芯片组合成2K×8；字位扩展先增加每个格子的容量再增加格子数量。
### 4.2.8 存储器的校验
#### 奇偶校验
**原理**：增加1位校验位，使数据中1的个数为奇数（奇校验）或偶数（偶校验）。
**特点**：简单，只能检测奇数位错误，不能纠错。
奇校验让数据中1的个数为奇数，比如数据 `10110001` 有4个1（偶数），校验位设为1变成 `101100011`（5个1）；偶校验让数据中1的个数为偶数。接收方检查1的个数是否符合约定，不符合说明有错误。
#### 海明码（Hamming Code）
**原理**：在数据位中插入多个校验位，通过校验位的组合定位错误位。
**校验位数r满足**：$2^r \geq m + r + 1$（m为数据位数）
**特点**：可以检测并纠正1位错误，可以检测2位错误。
8位数据需要4位校验码：总位数12位，校验位位置1、2、4、8，可以纠正1位错误。对于8位数据（m=8），$2^3 = 8 \geq 12$不满足，$2^4 = 16 \geq 13$满足，所以需要4位校验码。
---
## 4.3 高速缓冲存储器（Cache）
### 4.3.1 Cache的基本原理
> [!important] 为什么需要Cache
> CPU速度远快于主存，Cache作为中间缓冲，解决速度不匹配问题。
```mermaid
graph LR
CPU[CPU] <--> |"速度匹配"| CACHE[Cache]
CACHE <--> |"容量大"| MEM[主存]
style CPU fill:#ff9999
style CACHE fill:#ffcc99
style MEM fill:#99ff99
```
**工作原理**：
1. CPU访问数据时，先查Cache
2. **命中**：直接从Cache读取（快）
3. **未命中**：从主存读取，同时调入Cache
Cache就像办公桌上的常用文件架：你（CPU）找文件很快，但文件柜（主存）找文件慢，所以在桌上放一个常用文件架。找文件时先看文件架上有没有，有就直接拿（命中），没有就去文件柜拿同时放到文件架上（未命中）。
### 4.3.2 Cache命中率
**命中率**：
$$H = \frac{N_c}{N_c + N_m}$$
**平均访问时间**：
$$T_a = HT_c + (1-H)T_m$$
**访问效率**：
$$e = \frac{T_c}{T_a} = \frac{1}{H + (1-H)r}$$
其中 $r = T_m / T_c$（主存与Cache访问时间之比）
> [!example] 示例
> Cache命中率95%，Cache访问时间10ns，主存访问时间100ns：
> $$T_a = 0.95 \times 10 + 0.05 \times 100 = 14.5ns$$
> $$e = \frac{10}{14.5} = 69\%$$
命中率就像在文件架上找到文件的概率。假设文件架上找到文件的概率是95%，从文件架拿文件需要10秒，去文件柜拿需要100秒，平均每次拿文件需要0.95×10+0.05×100=14.5秒，效率10/14.5=69%。
如果命中率提高到99%，平均访问时间变为0.99×10+0.01×100=10.9ns，效率提高很多。
### 4.3.3 Cache地址映射
> [!info] 问题
> 主存块如何放入Cache？需要地址映射。
#### 1. 直接映射（Direct Mapping）
**规则**：每个主存块只能映射到Cache的固定行。
**映射公式**：$i = j \mod m$
- i：Cache行号
- j：主存块号
- m：Cache行数
```mermaid
graph LR
subgraph "直接映射"
M0[主存块0] --> C0[Cache行0]
M1[主存块1] --> C1[Cache行1]
Mm[主存块m] --> Cm[Cache行m]
Mm1[主存块m+1] --> C0
end
```
**地址结构**：
| 标记（Tag） | Cache行号（Index） | 块内地址（Offset） |
|-------------|-------------------|-------------------|
**优点**：实现简单，查找速度快
**缺点**：灵活性差，命中率低
直接映射就像图书馆的固定书架，每本书只能放在固定的书架上。要找某本书直接去对应的书架找，找得快但位置固定，如果两本书都想放在同一个书架就会冲突。
假设Cache有4行，主存有8块：主存块0→Cache行0（0 mod 4=0），主存块1→Cache行1，主存块2→Cache行2，主存块3→Cache行3，主存块4→Cache行0（冲突）。
#### 2. 全相联映射（Fully Associative Mapping）
**规则**：主存块可以映射到Cache的任意行。
```mermaid
graph LR
subgraph "全相联映射"
M0[主存块0] --> |"任意行"| CACHE[Cache]
M1[主存块1] --> |"任意行"| CACHE
Mn[主存块n] --> |"任意行"| CACHE
end
```
**地址结构**：
| 标记（Tag） | 块内地址（Offset） |
|-------------|-------------------|
**优点**：灵活性好，命中率高
**缺点**：查找速度慢，硬件成本高
全相联映射就像图书馆的自由书架，每本书可以放在任何书架上，灵活不会冲突，但找得慢因为要搜索所有书架。
#### 3. 组相联映射（Set Associative Mapping）
**规则**：将Cache分组，主存块映射到固定组，组内任意行。
**映射公式**：$q = j \mod u$
- q：组号
- j：主存块号
- u：组数
**地址结构**：
| 标记（Tag） | 组号（Index） | 块内地址（Offset） |
|-------------|--------------|-------------------|
**优点**：折中方案，兼顾速度和灵活性
**缺点**：实现复杂度中等
组相联映射就像图书馆的分组书架，每本书只能放在固定的组，但可以放在组内的任何书架上。先找对应的组，再在组内搜索，比直接映射灵活，比全相联映射快。
### 4.3.4 Cache替换策略
> [!info] 问题
> 当Cache满时，需要替换哪一行？需要替换策略。
| 策略 | 规则 | 优点 | 缺点 |
|------|------|------|------|
| **FIFO** | 先进先出 | 实现简单 | 可能替换常用数据 |
| **LRU** | 最近最少使用 | 命中率高 | 实现复杂 |
| **LFU** | 最不经常使用 | 考虑频率 | 需要计数器 |
| **随机替换** | 随机选择 | 实现简单 | 性能不稳定 |
FIFO（先进先出）最早放上去的文件先被替换，简单但可能把常用文件拿走；LRU（最近最少使用）最近最少用的文件先被替换，常用文件不容易被替换命中率高；LFU（最不经常使用）使用次数最少的文件先被替换；随机替换随机选择一个文件替换，实现简单但性能不稳定。
### 4.3.5 Cache写策略
> [!info] 问题
> 当CPU写数据时，如何保证Cache和主存数据一致性？需要写策略。
| 策略 | 规则 | 优点 | 缺点 |
|------|------|------|------|
| **写直达** | 同时写Cache和主存 | 数据一致 | 速度慢 |
| **写回** | 只写Cache，替换时写回主存 | 速度快 | 数据可能不一致 |
写直达每次修改文件同时修改文件架和文件柜，数据一致但每次都要去文件柜速度慢；写回只修改文件架，等文件架满了要替换时才去文件柜修改，速度快但数据可能不一致。大多数Cache系统用写回策略因为速度快。
---
## 4.4 虚拟存储器
### 4.4.1 虚拟存储器的基本概念
> [!info] 定义
> 虚拟存储器是一种通过硬件和软件结合，使程序认为自己拥有连续完整内存的技术。
虚拟存储器就像一个魔法书架：你的书架（主存）很小，但你的书（程序）很多，通过魔法让你觉得有一个很大的书架。只把常用的书放在书架上，不常用的书放在地下室（辅存），当你要看不在书架上的书时，魔法自动把书从地下室取来。
Windows的虚拟内存系统：主存是电脑的8GB内存，辅存是硬盘上的页面文件，让程序认为自己有32GB内存。
### 4.4.2 页式虚拟存储器
**基本概念**：
- **页面**：把程序和内存分成固定大小的块（通常4KB）
- **页表**：记录虚拟页面和物理页面的对应关系
- **缺页中断**：当访问的页面不在内存时，产生中断，从辅存调入
页式虚拟存储器就像图书馆的借书系统：页面是每本书分成固定大小的章节，页表是图书馆的借书记录，记录哪些章节在图书馆（内存）哪些在外面（辅存），缺页中断是你要看的章节不在图书馆需要去外面取。
### 4.4.3 段式虚拟存储器
**基本概念**：
- **段**：把程序按逻辑分成不同的段（代码段、数据段等）
- **段表**：记录段的起始地址和长度
- **段错误**：访问越界时产生错误
段式虚拟存储器就像图书馆的分类系统：段是图书馆按类别分成不同的区域（科技区、文学区等），段表是图书馆的区域地图，记录每个区域的位置和大小，段错误是你要去科技区却走到了文学区越界了。
### 4.4.4 段页式虚拟存储器
**基本概念**：
- **结合**：先分段，再分页
- **优点**：兼顾段式和页式的优点
- **缺点**：实现复杂
段页式虚拟存储器先按类别分成不同的区域，每个区域再分成固定大小的书架，既方便分类管理又方便查找。现代操作系统大多采用段页式虚拟存储器。
---
## 📝 本章小结
### 核心概念
1. **存储器层次**：寄存器 → Cache → 主存 → 辅存
2. **主存组成**：MAR、译码器、存储体、MDR、控制电路
3. **Cache原理**：解决CPU和主存速度不匹配
4. **虚拟存储器**：解决主存容量不足
### 关键术语
| 术语 | 英文 | 含义 |
|------|------|------|
| Cache | Cache | 高速缓冲存储器 |
| SRAM | Static RAM | 静态随机存取存储器 |
| DRAM | Dynamic RAM | 动态随机存取存储器 |
| Hit Rate | Hit Rate | 命中率 |
| Virtual Memory | Virtual Memory | 虚拟存储器 |
### 重点图示
> [!summary] 必须掌握的图
> 1. 存储器层次结构图
> 2. 主存组成框图
> 3. Cache地址映射方式
> 4. 虚拟存储器工作原理
---
## 🧪 例题与解析
### 例题1：存储容量计算
**题目**：某计算机有24位地址线，8位数据线，按字节寻址，求存储容量。
**答案**：
24位地址线可以表示 2²⁴ = 16777216 个地址，8位数据线表示每个单元存8位数据（1字节），存储容量 = 16777216 × 8位 = 16777216字节 = 16MB。
这就像一个仓库有16777216个格子，每个格子能放8个鸡蛋，总容量就是16MB。
### 例题2：Cache命中率计算
**题目**：某计算机Cache命中率为90%，Cache访问时间为20ns，主存访问时间为200ns，求平均访问时间和访问效率。
**答案**：
平均访问时间 $T_a = 0.9 × 20 + 0.1 × 200 = 18 + 20 = 38ns$
访问效率 $e = 20/38 = 52.6\%$
就像90%的时候你要的书在书架上，从书架拿书需要20秒，去档案室拿需要200秒，平均每次拿书需要38秒，效率52.6%。
### 例题3：Cache地址映射
**题目**：某计算机Cache有4行，采用直接映射，主存有16块，求主存块5映射到Cache的哪一行？
**答案**：
映射公式 $i = j \mod m = 5 \mod 4 = 1$，主存块5映射到Cache的第1行。
这就像4个书架，书号除以书架数余数就是书架号，5÷4=1余1，第5本书在第1个书架上。
### 例题4：存储器扩展
**题目**：用1K×4位的芯片组成4K×8位的存储器，需要多少芯片？如何连接？
**答案**：
位扩展：8位÷4位=2个芯片（增加字长）；字扩展：4K÷1K=4组（增加字数）；总芯片数：2×4=8个。
先位扩展，每2个芯片组成1K×8位，地址线、控制线并联，数据线串联；再字扩展，4组1K×8位组成4K×8位，地址线、数据线、控制线并联，用高位地址选择是哪一组。
### 例题5：海明码计算
**题目**：对于8位数据，需要多少位海明码校验位？写出校验位的位置。
**答案**：
校验位数r满足 $2^r \geq m + r + 1$，对于8位数据（m=8）：r=3时 $2^3=8 \geq 12$ 不满足，r=4时 $2^4=16 \geq 13$ 满足，所以需要4位校验码。
校验位放在2的幂次方位置：1、2、4、8，数据位放在其他位置：3、5、6、7、9、10、11、12。
---
## ⚡ 知识点速记卡
> 考前快速过一遍，30秒回忆整章核心
**存储层次**（从快到慢、从小到大）：寄存器 → Cache → 主存 → 磁盘 → 磁带。速度和容量不可兼得，靠层次结构解决。
**SRAM vs DRAM**：SRAM用触发器，快、不用刷新、贵、用于Cache；DRAM用电容，慢、要刷新、便宜、用于主存。
**主存组成**：MAR（地址）→ 译码器 → 存储体 ↔ MDR（数据），加上控制电路。
**容量扩展三种方式**：位扩展（增加字长，数据线串联）、字扩展（增加字数，片选线用高位地址）、字位同时扩展。
**Cache三个核心问题**：①映射（直接/全相联/组相联）②替换（FIFO/LRU/LFU/随机）③写策略（写直达/写回）。
**Cache命中率公式**：平均访问时间 T_a = H·T_c + (1-H)·T_m。命中率95%、Cache 10ns、主存100ns → T_a = 14.5ns。
**直接映射**：i = j mod m（主存块号 mod Cache行数），简单但冲突多。**组相联**：折中方案，先定组再组内任意放。
**虚拟存储器**：页式（固定大小页面+页表）、段式（逻辑分段+段表）、段页式（先分段再分页）。
**海明码**：校验位数r满足 2^r ≥ m+r+1，8位数据需要4位校验码，可纠正1位错误。
---
## 🔗 相关链接
- [[00_计算机组成原理学习指南]] - 返回主目录
- [[03_系统总线]] - 上一章
- [[05_输入输出系统]] - 下一章
- [[06_运算方法]] - 数据表示相关内容
---
*本章难度：⭐⭐⭐⭐⭐ 困难*
*重要程度：⭐⭐⭐⭐⭐ 重点*

583
计算机组成原理/学习笔记/05_输入输出系统.md Normal file
View File

@@ -0,0 +1,583 @@
# 第5章 输入输出系统
> 📖 本章介绍I/O设备与主机交换信息的三种控制方式：程序查询、中断和DMA。
> 🎯 重点理解中断处理过程和DMA工作原理
---
## 📋 本章目录
- [[#5.1 概述]]
- [[#5.2 I/O设备]]
- [[#5.3 接口]]
- [[#5.4 程序查询方式]]
- [[#5.5 程序中断方式]]
- [[#5.6 DMA方式]]
- [[#本章小结]]
---
## 5.1 概述
### 5.1.1 输入输出系统的发展
```mermaid
graph LR
A[早期阶段] --> B[接口模块阶段]
B --> C[DMA阶段]
C --> D[通道阶段]
D --> E[IO处理机阶段]
style A fill:#ff9999
style B fill:#ffcc99
style C fill:#ffff99
style D fill:#99ff99
style E fill:#99ccff
```
| 阶段 | 特点 | CPU参与度 |
|------|------|----------|
| 早期阶段 | IO设备直接连CPU，串行工作 | 完全参与 |
| 接口模块阶段 | 通过接口连接，可并行工作 | 部分参与 |
| DMA阶段 | IO与主存直接通路，CPU不参与数据传输 | 少量参与 |
| 通道阶段 | 通道独立管理IO | 不参与 |
| IO处理机阶段 | IO处理机独立工作 | 不参与 |
### 5.1.2 输入输出系统的组成
```mermaid
graph TB
A[输入输出系统] --> B[I/O软件]
A --> C[I/O硬件]
B --> B1[I/O指令]
B --> B2[通道指令]
B --> B3[管理程序]
C --> C1[I/O接口]
C --> C2[I/O设备]
```
#### I/O指令格式
```mermaid
graph LR
subgraph "I/O指令格式"
OP[操作码] --> CMD[命令码] --> DEV[设备码]
end
```
**命令码功能**：
- 数据输入（IO → CPU）
- 数据输出（CPU → IO）
- 状态测试（查询设备状态）
- 形成操作命令
---
## 5.2 I/O设备
### 5.2.1 I/O设备分类
| 类型 | 设备 | 特点 |
|------|------|------|
| 输入设备 | 键盘、鼠标、扫描仪 | 人 → 机 |
| 输出设备 | 显示器、打印机 | 机 → 人 |
| 外存储器 | 磁盘、磁带、光盘 | 存储信息 |
### 5.2.2 I/O设备与主机联系方式
```mermaid
graph TB
subgraph "联系方式"
A[I/O设备] --> B[编址方式]
B --> B1[统一编址]
B --> B2[独立编址]
A --> C[联络方式]
C --> C1[立即响应]
C --> C2[异步联络]
C --> C3[同步联络]
A --> D[连接方式]
D --> D1[辐射式]
D --> D2[总线式]
end
```
---
## 5.3 接口
### 5.3.1 接口的功能
> [!info] 接口定义
> 接口是主机与I/O设备之间的桥梁，实现数据缓冲、格式转换和控制信号传递。
**主要功能**：
1. **选址功能**：识别设备地址
2. **传送命令**：接收并执行CPU命令
3. **传送数据**：缓冲数据传输
4. **反映状态**：向CPU报告设备状态
### 5.3.2 接口的组成
```mermaid
graph TB
subgraph "I/O接口"
DR[数据缓冲寄存器] <--> |"数据"| DATA[数据总线]
CR[控制/状态寄存器] <--> |"控制"| CTRL[控制总线]
AR[设备选择电路] <--> |"地址"| ADDR[地址总线]
DR --> |"数据"| DEV[I/O设备]
CR --> |"控制"| DEV
end
```
**寄存器说明**：
| 寄存器 | 功能 | 方向 |
|--------|------|------|
| 数据缓冲寄存器 | 暂存传输数据 | 双向 |
| 控制寄存器 | 存放CPU命令 | CPU→接口 |
| 状态寄存器 | 存放设备状态 | 接口→CPU |
| 设备选择电路 | 识别设备地址 | CPU→接口 |
### 5.3.3 接口类型
| 类型 | 特点 | 应用 |
|------|------|------|
| 并行接口 | 数据并行传输 | 近距离 |
| 串行接口 | 数据串行传输 | 远距离 |
| 可编程接口 | 功能可编程设置 | 灵活应用 |
---
## 5.4 程序查询方式
### 5.4.1 工作原理
> [!info] 核心思想
> CPU主动查询I/O设备状态，设备准备好后才进行数据传输。
```mermaid
sequenceDiagram
participant CPU
participant IO as I/O设备
loop 查询过程
CPU->>IO: 查询状态
IO-->>CPU: 返回状态
alt 设备未就绪
Note over CPU: 继续查询
else 设备就绪
CPU->>IO: 传输数据
IO-->>CPU: 完成传输
end
end
```
### 5.4.2 程序流程
```mermaid
graph TB
START[开始] --> INIT[初始化]
INIT --> QUERY[查询状态]
QUERY --> CHECK{就绪?}
CHECK -->|否| QUERY
CHECK -->|是| TRANS[传输数据]
TRANS --> NEXT[下一个数据?]
NEXT -->|是| QUERY
NEXT -->|否| END[结束]
```
### 5.4.3 特点分析
| 优点 | 缺点 |
|------|------|
| 实现简单 | CPU效率低 |
| 硬件成本低 | 实时性差 |
| 易于理解 | 不能并行工作 |
> [!warning] 适用场景
> 适用于I/O设备较少、数据传输不频繁的简单系统。
---
## 5.5 程序中断方式
### 5.5.1 中断的概念
> [!info] 定义
> 中断是指CPU暂停现行程序，转去处理中断请求，处理完毕后返回原程序继续执行。
```mermaid
sequenceDiagram
participant CPU
participant IO as I/O设备
Note over CPU: 执行主程序
CPU->>IO: 启动设备
Note over CPU: 继续执行主程序
Note over IO: 设备准备数据
IO->>CPU: 中断请求
Note over CPU: 保存现场
CPU->>IO: 中断响应
Note over CPU: 执行中断服务程序
CPU->>IO: 传输数据
Note over CPU: 恢复现场
Note over CPU: 返回主程序
```
### 5.5.2 中断系统的功能
#### 1. 中断请求
```mermaid
graph LR
subgraph "中断请求信号"
INTR[INTR<br/>可屏蔽中断] --> CPU
NMI[NMI<br/>不可屏蔽中断] --> CPU
end
```
**中断源分类**：
- **外部中断**：I/O设备请求、定时器中断
- **内部中断**：溢出、除零、缺页
#### 2. 中断判优
> [!info] 问题
> 多个中断同时请求时，如何确定优先级？
**判优方法**：
| 方法 | 原理 | 特点 |
|------|------|------|
| 硬件判优 | 硬件优先级电路 | 速度快 |
| 软件判优 | 程序查询顺序 | 灵活，速度慢 |
**优先级原则**：
- 硬件故障 > 软件中断
- 高速设备 > 低速设备
- 输入 > 输出
- 实时设备 > 普通设备
#### 3. 中断响应
**响应条件**：
1. 中断源有请求
2. CPU允许中断（开中断）
3. 一条指令执行完毕
4. 没有更高优先级中断
**响应过程**：
1. 关中断
2. 保存断点（PC、PSW）
3. 识别中断源
4. 转入中断服务程序
#### 4. 中断处理
```mermaid
graph TB
subgraph "中断处理过程"
A[关中断] --> B[保存断点]
B --> C[保存现场]
C --> D[识别中断源]
D --> E[执行中断服务程序]
E --> F[恢复现场]
F --> G[开中断]
G --> H[返回断点]
end
```
#### 5. 中断返回
**返回指令**：IRET（中断返回）
**功能**：
1. 恢复断点（PC）
2. 恢复程序状态字（PSW）
3. 开中断
### 5.5.3 中断服务程序流程
```mermaid
graph TB
START[中断响应] --> SAVE1[保存断点]
SAVE1 --> SAVE2[保存现场]
SAVE2 --> EI[开中断]
EI --> SERVICE[执行服务程序]
SERVICE --> DI[关中断]
DI --> RESTORE1[恢复现场]
RESTORE1 --> RESTORE2[恢复断点]
RESTORE2 --> RET[中断返回]
```
> [!note] 现场保存
> - **断点**：由硬件自动保存（PC、PSW）
> - **现场**：由软件保存（通用寄存器）
### 5.5.4 多重中断
> [!info] 概念
> 在处理中断时，允许更高优先级的中断打断当前中断处理。
**实现方法**：
1. 中断服务程序开始时**关中断**
2. 保存现场后**开中断**
3. 允许更高优先级中断
4. 返回前**关中断**
```mermaid
sequenceDiagram
participant CPU
participant IO1 as 低优先级设备
participant IO2 as 高优先级设备
Note over CPU: 执行主程序
IO1->>CPU: 中断请求1
Note over CPU: 保存现场，开中断
Note over CPU: 执行服务程序1
IO2->>CPU: 中断请求2（优先级高）
Note over CPU: 保存现场，开中断
Note over CPU: 执行服务程序2
Note over CPU: 恢复现场，返回
Note over CPU: 继续服务程序1
Note over CPU: 恢复现场，返回
Note over CPU: 继续主程序
```
### 5.5.5 中断接口
```mermaid
graph TB
subgraph "中断接口"
DR[数据缓冲寄存器] <--> DATA[数据总线]
AR[设备选择电路] <--> ADDR[地址总线]
IR[中断请求触发器] --> INTR[INTR线]
IM[中断屏蔽触发器] --> MASK[屏蔽信号]
READY[准备就绪触发器] --> DR
end
```
**关键触发器**：
- **中断请求触发器（IR）**：记录中断请求
- **中断屏蔽触发器（IM）**：控制中断是否允许
- **准备就绪触发器（READY）**：设备是否就绪
### 5.5.6 程序中断方式特点
| 优点 | 缺点 |
|------|------|
| CPU效率提高 | 保护和恢复现场开销 |
| 实时性好 | 硬件成本增加 |
| 可处理突发事件 | 程序设计复杂 |
---
## 5.6 DMA方式
### 5.6.1 DMA的基本概念
> [!info] 定义
> DMA（Direct Memory Access）是I/O设备与主存直接进行数据交换，不经过CPU的方式。
```mermaid
graph TB
subgraph "DMA方式"
CPU[CPU] <--> |"控制"| DMA[DMA控制器]
DMA <--> |"数据"| MEM[主存]
DMA <--> |"数据"| IO[I/O设备]
CPU -.-> |"不参与数据传输"| MEM
end
```
**特点**：
- 数据传输不经过CPU
- CPU与I/O设备并行工作
- 适用于高速I/O设备
### 5.6.2 DMA与中断方式对比
| 特性 | 中断方式 | DMA方式 |
|------|----------|---------|
| 数据传输 | 通过CPU | 直接访问主存 |
| CPU参与 | 参与每次传输 | 只参与启动和结束 |
| 传输单位 | 字 | 数据块 |
| 适用速度 | 中低速设备 | 高速设备 |
| 开销 | 保护/恢复现场 | 硬件成本 |
### 5.6.3 DMA传送方式
#### 1. 停止CPU访问主存
```mermaid
sequenceDiagram
participant CPU
participant DMA
participant MEM as 主存
Note over CPU: 正常访问主存
DMA->>CPU: DMA请求
Note over CPU: 停止访问主存
DMA->>MEM: 数据传输
Note over CPU: 等待
DMA->>CPU: DMA结束
Note over CPU: 恢复访问主存
```
**特点**：CPU处于空闲状态，效率低
#### 2. 周期挪用（Cycle Stealing）
```mermermaid
sequenceDiagram
participant CPU
participant DMA
participant MEM as 主存
Note over CPU: 执行指令
DMA->>DMA: DMA请求
Note over DMA: 等待CPU周期结束
DMA->>MEM: 挪用一个周期传输
Note over CPU: 继续执行
Note over DMA: 重复挪用
```
**特点**：CPU效率影响小，常用
#### 3. DMA与CPU交替访问
```mermaid
sequenceDiagram
participant CPU
participant DMA
participant MEM as 主存
Note over CPU,DMA: CPU周期
CPU->>MEM: CPU访问
Note over CPU,DMA: DMA周期
DMA->>MEM: DMA访问
Note over CPU,DMA: 交替进行
```
**特点**：效率最高，硬件复杂
### 5.6.4 DMA控制器组成
```mermaid
graph TB
subgraph "DMA控制器"
AR[地址寄存器] <--> |"地址"| MEM[主存]
WC[字计数器] --> |"计数"| CTRL[控制逻辑]
DAR[数据缓冲寄存器] <--> |"数据"| IO[I/O设备]
CSR[控制状态寄存器] <--> |"控制"| CPU
CTRL --> |"请求"| DREQ[DREQ线]
CTRL <--> |"响应"| DACK[DACK线]
end
```
**寄存器功能**：
| 寄存器 | 功能 |
|--------|------|
| 地址寄存器（AR） | 存放主存地址，每次传输后+1 |
| 字计数器（WC） | 存放传输字数，每次传输后-1 |
| 数据缓冲寄存器（DAR） | 暂存传输数据 |
| 控制状态寄存器（CSR） | 存放控制命令和状态 |
### 5.6.5 DMA传送过程
```mermaid
graph TB
subgraph "DMA传送过程"
A[CPU初始化DMA] --> B[DMA请求]
B --> C[DMA响应]
C --> D[数据传输]
D --> E{传输完成?}
E -->|否| D
E -->|是| F[DMA结束]
F --> G[中断CPU]
G --> H[CPU处理]
end
```
**详细步骤**：
1. **预处理**（CPU完成）：
- 设置起始地址
- 设置传输字数
- 设置传输方向
- 启动DMA
2. **数据传输**（DMA完成）：
- 地址送主存
- 发读/写命令
- 数据传输
- 地址+1，字计数-1
3. **后处理**（CPU完成）：
- 检测传输是否出错
- 是否继续传输
### 5.6.6 DMA方式特点
| 优点 | 缺点 |
|------|------|
| 传输速度快 | 硬件成本高 |
| CPU效率高 | 控制复杂 |
| 适用于高速设备 | 需要额外硬件 |
---
## 📝 本章小结
### 核心概念
1. **三种IO方式**：程序查询、程序中断、DMA
2. **中断处理**：中断请求 → 判优 → 响应 → 处理 → 返回
3. **DMA方式**：直接访问主存，CPU不参与数据传输
### 关键对比
| 方式 | CPU参与度 | 传输单位 | 速度 | 复杂度 |
|------|----------|----------|------|--------|
| 程序查询 | 完全 | 字 | 慢 | 低 |
| 程序中断 | 部分 | 字 | 中 | 中 |
| DMA | 极少 | 数据块 | 快 | 高 |
### 重点图示
> [!summary] 必须掌握的图
> 1. 中断处理流程图
> 2. DMA控制器组成框图
> 3. 三种IO方式工作时序对比图
---
## 🧪 自测练习
### 概念题
1. 比较三种IO方式的特点和适用场景。
2. 说明中断处理的基本过程。
3. 解释DMA的三种传送方式。
### 分析题
1. 设计一个支持多重中断的处理流程。
2. 说明DMA控制器的工作原理。
---
## 🔗 相关链接
- [[04_存储器]] - 上一章
- [[06_运算方法]] - 下一章
- [[08_CPU结构与功能]] - CPU中断处理
---
*本章难度：⭐⭐⭐ 中等*
*重要程度：⭐⭐⭐⭐ 重点*

441
计算机组成原理/学习笔记/05_输入输出系统_补充版.md Normal file
View File

@@ -0,0 +1,441 @@
# 第5章 输入输出系统
> 📖 本章介绍I/O设备与主机交换信息的三种控制方式：程序查询、中断和DMA。
> 🎯 重点理解中断处理过程和DMA工作原理
---
## 📋 本章目录
- [[#5.1 概述]]
- [[#5.2 I/O设备]]
- [[#5.3 接口]]
- [[#5.4 程序查询方式]]
- [[#5.5 程序中断方式]]
- [[#5.6 DMA方式]]
- [[#本章小结]]
- [[#例题与解析]]
---
## 5.1 概述
### 5.1.1 输入输出系统的发展
```mermaid
graph LR
A[早期阶段] --> B[接口模块阶段]
B --> C[DMA阶段]
C --> D[通道阶段]
D --> E[IO处理机阶段]
style A fill:#ff9999
style B fill:#ffcc99
style C fill:#ffff99
style D fill:#99ff99
style E fill:#99ccff
```
| 阶段 | 特点 | CPU参与度 |
|------|------|----------|
| 早期阶段 | IO设备直接连CPU，串行工作 | 完全参与 |
| 接口模块阶段 | 通过接口连接，可并行工作 | 部分参与 |
| DMA阶段 | IO与主存直接通路，CPU不参与数据传输 | 少量参与 |
| 通道阶段 | 通道独立管理IO | 不参与 |
| IO处理机阶段 | IO处理机独立工作 | 不参与 |
I/O系统的发展可以理解为物流系统的进化：早期阶段CPU亲自搬运所有货物，效率低下；接口模块阶段有了快递员（接口），CPU可以做其他事情；DMA阶段有了直达通道，I/O设备和内存之间直接传送数据；通道阶段有了物流中心（通道）独立管理；I/O处理机阶段有了独立物流公司完全独立工作。
### 5.1.2 输入输出系统的组成
```mermaid
graph TB
A[输入输出系统] --> B[I/O软件]
A --> C[I/O硬件]
B --> B1[I/O指令]
B --> B2[通道指令]
B --> B3[管理程序]
C --> C1[I/O接口]
C --> C2[I/O设备]
```
#### I/O指令格式
```mermaid
graph LR
subgraph "I/O指令格式"
OP[操作码] --> CMD[命令码] --> DEV[设备码]
end
```
**命令码功能**：
- 数据输入（IO → CPU）
- 数据输出（CPU → IO）
- 状态测试（查询设备状态）
- 形成操作命令
I/O指令就像快递单：操作码告诉CPU要做什么操作（读数据、写数据、查询状态），命令码告诉I/O设备要做什么，设备码告诉CPU是哪个I/O设备（打印机、硬盘、键盘）。
---
## 5.2 I/O设备
### 5.2.1 I/O设备分类
| 类型 | 设备 | 特点 |
|------|------|------|
| 输入设备 | 键盘、鼠标、扫描仪 | 人 → 机 |
| 输出设备 | 显示器、打印机 | 机 → 人 |
| 外存储器 | 磁盘、磁带、光盘 | 存储信息 |
输入设备像人的感官（键盘像手，鼠标像手，扫描仪像眼睛），接收外界信息传给计算机；输出设备像表达器官（显示器像眼睛，打印机像手），把计算机的信息传给人；外存储器像记忆器官（磁盘像大脑，磁带像笔记本），存储信息长期保存。
### 5.2.2 I/O设备与主机联系方式
```mermaid
graph TB
subgraph "联系方式"
A[I/O设备] --> B[编址方式]
B --> B1[统一编址]
B --> B2[独立编址]
A --> C[联络方式]
C --> C1[立即响应]
C --> C2[异步联络]
C --> C3[同步联络]
end
```
#### 编址方式
| 方式 | 特点 | 优点 | 缺点 |
|------|------|------|------|
| **统一编址** | I/O设备和内存使用同一地址空间 | 指令统一，编程简单 | 占用内存地址 |
| **独立编址** | I/O设备和内存使用不同地址空间 | 不占用内存地址 | 指令不同，编程复杂 |
统一编址就像办公室和仓库使用同一套门牌号，找办公室和仓库都用同一套门牌号简单，但仓库占用了办公室的门牌号；独立编址就像办公室和仓库使用不同的门牌号系统，仓库不占用办公室的门牌号，但找办公室和仓库要用不同的门牌号系统复杂。
#### 联络方式
| 方式 | 特点 | 适用场景 |
|------|------|----------|
| **立即响应** | 设备立即响应CPU请求 | 简单设备 |
| **异步联络** | 使用握手信号，速度灵活 | 大多数设备 |
| **同步联络** | 使用统一时钟，速度固定 | 高速设备 |
立即响应就像你问一个问题对方立即回答，只能用于简单设备；异步联络像你问一个问题对方准备好后回答，速度灵活适合大多数设备；同步联络像所有设备按同一时钟工作，速度快但受限于最慢设备。
---
## 5.3 接口
### 5.3.1 I/O接口的功能
**主要功能**：
1. **设备选择**：选择是哪个I/O设备
2. **数据缓冲**：缓冲数据，解决速度不匹配
3. **数据格式转换**：串行/并行转换
4. **控制命令传递**：传递CPU的控制命令
5. **状态反馈**：反馈设备状态
I/O接口就像快递站：设备选择告诉快递站是哪个包裹，数据缓冲暂时存放包裹解决速度不匹配，数据格式转换把包裹转换成适合运输的形式，控制命令传递传递发货人的命令，状态反馈反馈包裹的状态。
### 5.3.2 I/O接口的类型
| 类型 | 特点 | 应用 |
|------|------|------|
| **并行接口** | 多位数据同时传输 | 打印机接口 |
| **串行接口** | 一位一位传输 | USB、网络 |
| **专用接口** | 为特定设备设计 | 显卡接口 |
并行接口像8个人同时送8封信，速度快但成本高距离短；串行接口像一个人送8封信分8次送，成本低距离长但速度慢；专用接口专门为某种设备设计，性能好兼容性好但只能用于特定设备。
---
## 5.4 程序查询方式
### 5.4.1 工作原理
```mermaid
graph TB
A[CPU启动设备] --> B[CPU查询设备状态]
B --> C{设备准备好?}
C -->|否| B
C -->|是| D[CPU传输数据]
D --> E[操作完成]
```
**工作流程**：
1. CPU启动I/O设备
2. CPU不断查询设备状态
3. 设备准备好后，CPU传输数据
4. 操作完成
程序查询方式就像你等公交车：你到公交站等车（CPU启动设备），不断看公交站牌看车来了没有（查询设备状态），公交车来了（设备准备好），你上车（CPU传输数据），到达目的地（操作完成）。
**特点**：
- **优点**：简单，容易实现
- **缺点**：CPU要不断查询，效率低
早期计算机和简单嵌入式系统常用这种方式，CPU要等打印机打印完才能做其他事情。
---
## 5.5 程序中断方式
### 5.5.1 中断的基本概念
> [!info] 定义
> 中断是指CPU暂时中止当前程序，转去处理某个紧急事件，处理完后返回原程序继续执行。
中断就像你正在工作时有人敲门：你正在工作（CPU执行程序），有人按门铃（I/O设备请求服务），你暂停工作（CPU暂停当前程序），去开门（CPU处理中断请求），回来继续工作（CPU返回原程序继续执行）。
### 5.5.2 中断的分类
| 分类方式 | 类型 | 特点 |
|----------|------|------|
| **产生原因** | 硬件中断、软件中断 | 硬件中断由设备产生，软件中断由程序产生 |
| **是否可屏蔽** | 可屏蔽中断、不可屏蔽中断 | 可屏蔽中断可以被禁止，不可屏蔽中断不能 |
| **优先级** | 高优先级、低优先级 | 高优先级中断可以打断低优先级中断 |
硬件中断像有人按门铃，由硬件设备产生；软件中断像你自己决定要开门，由程序产生。可屏蔽中断像你可以选择不开门，某些不重要的中断可以被禁止；不可屏蔽中断像你必须开门，电源故障、硬件错误不能被禁止。
### 5.5.3 中断处理过程
```mermaid
graph TB
A[中断请求] --> B[中断判优]
B --> C[中断响应]
C --> D[保存现场]
D --> E[中断服务]
E --> F[恢复现场]
F --> G[中断返回]
```
**详细流程**：
1. **中断请求**：I/O设备向CPU发送中断请求信号，CPU在每条指令执行完后检查中断请求
2. **中断判优**：如果有多个中断请求，需要判优，优先级高的中断先处理
3. **中断响应**：CPU响应中断请求，关中断防止新的中断打断
4. **保存现场**：保存当前程序的状态（PC、寄存器等），以便中断返回后继续执行
5. **中断服务**：执行中断服务程序，处理I/O设备的请求
6. **恢复现场**：恢复之前保存的状态，准备返回原程序
7. **中断返回**：返回原程序继续执行，开中断允许新的中断
这就像你正在工作时有人敲门：有人按门铃（中断请求），如果有多个人按门铃决定先开哪个门（中断判优），你决定去开门（中断响应），把正在做的工作记下来（保存现场），去开门处理事情（中断服务），回来看看之前做到哪里了（恢复现场），继续之前的工作（中断返回）。
当你按键盘时：键盘向CPU发送中断请求，如果有其他中断键盘中断可能优先级较低，CPU响应键盘中断，保存当前程序的状态，执行键盘中断服务程序处理按键，恢复之前保存的状态，返回原程序继续执行。
### 5.5.4 中断判优方法
| 方法 | 特点 | 优点 | 缺点 |
|------|------|------|------|
| **软件查询** | CPU用程序查询哪个设备请求中断 | 简单，灵活 | 速度慢 |
| **硬件判优** | 用硬件电路判优 | 速度快 | 复杂，成本高 |
软件查询像你挨个问"是你按门铃吗？"，简单容易实现但速度慢；硬件判优像有一个专门的设备告诉你谁按了门铃，速度快立即知道是谁但需要额外设备成本高。
### 5.5.5 中断优先级
**设置原则**：
1. **硬件故障中断**：最高优先级
2. **软件中断**：较高优先级
3. **I/O中断**：中等优先级
4. **用户程序中断**：较低优先级
硬件故障中断像火灾报警最紧急，软件中断像重要电话比较紧急，I/O中断像门铃响了一般紧急，用户程序中断像有人找你聊天不紧急。
### 5.5.6 中断屏蔽
**原理**：通过设置中断屏蔽字，可以禁止某些中断。
中断屏蔽就像你设置了"请勿打扰"，设置了门铃响了你也不去开门；不设置门铃响了你就去开门。CPU正在处理重要任务时屏蔽某些中断，CPU空闲时允许所有中断。
---
## 5.6 DMA方式
### 5.6.1 DMA的基本概念
> [!info] 定义
> DMA（Direct Memory Access）是指I/O设备和内存之间直接传送数据，不经过CPU。
DMA就像直达快递：传统方式你要从A地寄东西到B地必须经过C地（CPU），DMA方式A地直接寄到B地不经过C地。硬盘读取数据时直接把数据传到内存不经过CPU。
### 5.6.2 DMA的工作方式
| 方式 | 特点 | 优点 | 缺点 |
|------|------|------|------|
| **停止CPU访问** | DMA传送时，CPU停止访问内存 | 简单 | CPU效率低 |
| **周期挪用** | DMA在CPU不访问内存时传送 | CPU效率高 | 控制复杂 |
| **交替访问** | DMA和CPU交替访问内存 | 效率最高 | 硬件复杂 |
停止CPU访问像高速公路完全给DMA使用，CPU不能使用，简单但CPU效率低；周期挪用像DMA在CPU不使用高速公路时使用，CPU效率高但需要复杂的控制逻辑；交替访问像DMA和CPU轮流使用高速公路，效率最高但硬件复杂成本高。
### 5.6.3 DMA的工作过程
```mermaid
graph TB
A[CPU初始化DMA] --> B[DMA请求]
B --> C[DMA响应]
C --> C1[DMA接管总线]
C1 --> D[数据传送]
D --> E[传送完成]
E --> F[DMA释放总线]
F --> G[CPU继续工作]
```
**详细流程**：
1. **CPU初始化DMA**：CPU设置DMA控制器的参数，包括内存起始地址、传送字节数、传送方向
2. **DMA请求**：I/O设备向DMA控制器发送请求，DMA控制器向CPU发送总线请求
3. **DMA响应**：CPU响应总线请求，DMA控制器接管总线
4. **数据传送**：DMA控制器控制数据传送，I/O设备和内存直接传送数据
5. **传送完成**：DMA控制器传送完成，向CPU发送中断请求
6. **DMA释放总线**：DMA控制器释放总线，CPU继续工作
这就像你让快递员帮你寄东西：你告诉快递员要寄什么东西寄到哪里（CPU初始化DMA），快递员去取东西（DMA请求），快递员拿到东西（DMA响应），快递员把东西送到目的地（数据传送），快递员告诉你东西送到了（传送完成），快递员去忙其他事情（DMA释放总线）。
当你从硬盘复制文件到内存时：CPU告诉DMA控制器要从硬盘读取多少数据到内存哪里，DMA控制器向CPU请求总线使用权，CPU把总线使用权给DMA控制器，硬盘直接把数据传到内存不经过CPU，DMA控制器告诉CPU传送完成了，DMA控制器释放总线CPU继续工作。
### 5.6.4 DMA与中断的区别
| 特性 | DMA | 中断 |
|------|-----|------|
| **数据传送** | I/O和内存直接传送 | 通过CPU传送 |
| **CPU参与度** | 只在开始和结束参与 | 全程参与 |
| **响应时间** | 每个机器周期结束响应 | 每条指令结束响应 |
| **适用场景** | 大量数据传送 | 少量数据传送 |
DMA像直达快递，东西直接从A地寄到B地不经过C地，速度快C地可以做其他事情但需要额外的快递员；中断像普通快递，东西从A地寄到C地再从C地寄到B地，简单不需要额外快递员但速度慢C地要全程参与。
硬盘读取大量数据到内存用DMA，键盘按键、鼠标点击用中断。
---
## 📝 本章小结
### 核心概念
1. **I/O系统发展**：从CPU完全参与到完全不参与
2. **I/O设备**：输入设备、输出设备、外存储器
3. **I/O接口**：设备选择、数据缓冲、格式转换
4. **程序查询**：CPU不断查询，效率低
5. **程序中断**：CPU响应中断，效率较高
6. **DMA**：I/O和内存直接传送，效率最高
### 关键术语
| 术语 | 英文 | 含义 |
|------|------|------|
| I/O | Input/Output | 输入输出 |
| DMA | Direct Memory Access | 直接内存访问 |
| Interrupt | Interrupt | 中断 |
| Interface | Interface | 接口 |
### 重点图示
> [!summary] 必须掌握的图
> 1. I/O系统发展过程图
> 2. 中断处理过程图
> 3. DMA工作过程图
> 4. 三种I/O方式的比较
---
## 🧪 例题与解析
### 例题1：中断处理过程
**题目**：简述中断处理的完整过程。
**答案**：
中断处理的完整过程：中断请求（I/O设备向CPU发送中断请求信号），中断判优（如果有多个中断请求决定先处理哪个），中断响应（CPU响应中断请求，关中断），保存现场（保存当前程序的状态），中断服务（执行中断服务程序），恢复现场（恢复之前保存的状态），中断返回（返回原程序继续执行，开中断）。
这就像你正在工作时有人敲门：有人按门铃，如果有多个人按门铃决定先开哪个门，你决定去开门，把正在做的工作记下来，去开门处理事情，回来看看之前做到哪里了，继续之前的工作。
### 例题2：DMA与中断比较
**题目**：比较DMA和中断两种I/O方式的区别。
**答案**：
DMA是I/O和内存直接传送，CPU只在开始和结束参与，每个机器周期结束响应，适合大量数据传送；中断是通过CPU传送，CPU全程参与，每条指令结束响应，适合少量数据传送。
DMA像直达快递，东西直接从A地寄到B地不经过C地，速度快C地可以做其他事情但需要额外的快递员；中断像普通快递，东西从A地寄到C地再从C地寄到B地，简单不需要额外快递员但速度慢C地要全程参与。
### 例题3：程序查询方式
**题目**：简述程序查询方式的工作原理和优缺点。
**答案**：
工作原理：CPU启动I/O设备，不断查询设备状态，设备准备好后CPU传输数据，操作完成。优点是简单容易实现，不需要额外硬件；缺点是CPU效率低要不断查询，不能同时处理多个设备。
这就像你等公交车：你到公交站等车，不断看公交站牌看车来了没有，公交车来了你上车，到达目的地。简单但你不能做其他事情效率低。
### 例题4：中断优先级
**题目**：简述中断优先级的设置原则。
**答案**：
硬件故障中断最高优先级（火灾报警最紧急），软件中断较高优先级（重要电话比较紧急），I/O中断中等优先级（门铃响了一般紧急），用户程序中断较低优先级（有人找你聊天不紧急）。
### 例题5：DMA工作过程
**题目**：简述DMA的完整工作过程。
**答案**：
DMA的完整工作过程：CPU初始化DMA（设置参数），DMA请求（I/O设备向DMA控制器发送请求），DMA响应（CPU响应总线请求，DMA控制器接管总线），数据传送（I/O设备和内存直接传送数据），传送完成（向CPU发送中断请求），DMA释放总线（CPU继续工作）。
这就像你让快递员帮你寄东西：你告诉快递员要寄什么东西寄到哪里，快递员去取东西，快递员拿到东西，快递员把东西送到目的地，快递员告诉你东西送到了，快递员去忙其他事情。
---
## ⚡ 知识点速记卡
> 考前快速过一遍，30秒回忆整章核心
**三种I/O方式**（CPU参与度从高到低）：程序查询（CPU一直等）→ 程序中断（设备准备好通知CPU）→ DMA（I/O和内存直接传，CPU只管开头和结尾）。
**程序查询**：CPU不断轮询设备状态，简单但CPU效率最低，适合简单嵌入式系统。
**中断处理七步**：中断请求 → 中断判优 → 中断响应（关中断）→ 保存现场 → 中断服务 → 恢复现场 → 中断返回（开中断）。
**中断优先级**：硬件故障 > 软件中断 > I/O中断 > 用户程序。
**DMA三大要点**：①I/O和内存直接传送，不经过CPU ②CPU只在初始化和结束时参与 ③每个机器周期结束时响应（比中断更快）。
**DMA三种工作方式**：停止CPU访问（简单但CPU空等）、周期挪用（CPU不访存时DMA传送）、交替访问（效率最高但硬件复杂）。
**DMA vs 中断**：DMA适合大量数据传送（硬盘），中断适合少量数据（键盘）。DMA在机器周期末响应，中断在指令周期末响应。
---
## 🔗 相关链接
- [[00_计算机组成原理学习指南]] - 返回主目录
- [[04_存储器]] - 上一章
- [[06_运算方法]] - 下一章
- [[08_CPU结构与功能]] - CPU相关内容
---
*本章难度：⭐⭐⭐⭐ 中等*
*重要程度：⭐⭐⭐⭐ 重要*

477
计算机组成原理/学习笔记/06_运算方法.md Normal file
View File

@@ -0,0 +1,477 @@
# 第6章 运算方法
> 📖 本章介绍计算机中数据的表示方法和算术运算，是课程的重点和难点。
> 🎯 重点理解补码运算和浮点数表示
---
## 📋 本章目录
- [[#6.1 无符号数和有符号数]]
- [[#6.2 定点数]]
- [[#6.3 浮点数]]
- [[#6.4 定点运算]]
- [[#6.5 浮点运算]]
- [[#本章小结]]
---
## 6.1 无符号数和有符号数
### 6.1.1 无符号数
> [!info] 定义
> 没有符号的数，所有位都表示数值。
**表示范围**（n位）：
$$0 \sim 2^n - 1$$
> [!example] 示例
> 16位无符号数：0 ~ 65535
### 6.1.2 有符号数
#### 机器数与真值
| 概念 | 定义 | 示例 |
|------|------|------|
| **真值** | 带正负号的数 | +1100, -1100 |
| **机器数** | 符号数字化的数 | 0,1100, 1,1100 |
**符号编码**：
- 0 表示正数
- 1 表示负数
#### 1. 原码表示法
> [!info] 定义
> 符号位 + 数值的绝对值
**整数原码**：
$$[x]_{原} = \begin{cases} 0,x & 2^n > x \geq 0 \\ 2^n - x & 0 \geq x > -2^n \end{cases}$$
**小数原码**：
$$[x]_{原} = \begin{cases} x & 1 > x \geq 0 \\ 1 - x & 0 \geq x > -1 \end{cases}$$
> [!example] 示例
> - x = +1110 → [x]原 = 0,1110
> - x = -1110 → [x]原 = 1,1110
> - x = +0.1101 → [x]原 = 0.1101
> - x = -0.1101 → [x]原 = 1.1101
**零的表示**：
- [+0]原 = 0.0000
- [-0]原 = 1.0000
**特点**：
- 表示简单，易于转换
- 加减运算复杂
- 零有两种表示
#### 2. 补码表示法
> [!important] 核心思想
> 用正数代替负数，将减法转换为加法。
**补数的概念**（时钟例子）：
- 时钟模为12
- -3 ≡ +9 (mod 12)
- 9 - 5 = 9 + 7 = 16 ≡ 4 (mod 12)
**整数补码**：
$$[x]_{补} = \begin{cases} 0,x & 2^n > x \geq 0 \\ 2^{n+1} + x & 0 > x \geq -2^n \end{cases}$$
**小数补码**：
$$[x]_{补} = \begin{cases} x & 1 > x \geq 0 \\ 2 + x & 0 > x \geq -1 \end{cases}$$
> [!example] 示例
> - x = +1010 → [x]补 = 0,1010
> - x = -1010 → [x]补 = 2^5 + (-1010) = 100000 - 1010 = 1,0110
> - x = +0.1001 → [x]补 = 0.1001
> - x = -0.1001 → [x]补 = 2 + (-0.1001) = 1.0111
**零的表示**：
- [+0]补 = [-0]补 = 0.0000（唯一表示）
**补码范围**（n位整数）：
$$-2^n \sim +(2^n - 1)$$
> [!warning] 特殊值
> 8位补码：-128的补码为10000000，没有对应的原码
#### 3. 反码表示法
**整数反码**：
$$[x]_{反} = \begin{cases} 0,x & 2^n > x \geq 0 \\ (2^{n+1}-1) + x & 0 \geq x > -2^n \end{cases}$$
**小数反码**：
$$[x]_{反} = \begin{cases} x & 1 > x \geq 0 \\ (2-2^{-n}) + x & 0 \geq x > -1 \end{cases}$$
> [!example] 示例
> - x = +1101 → [x]反 = 0,1101
> - x = -1101 → [x]反 = 1,0010
**零的表示**：
- [+0]反 = 0.0000
- [-0]反 = 1.1111
#### 4. 移码表示法
> [!info] 定义
> 移码 = 补码符号位取反
**用途**：便于比较大小（移码大的真值大）
**整数移码**：
$$[x]_{移} = 2^n + x \quad (-2^n \leq x < 2^n)$$
> [!example] 示例
> - x = +1010 → [x]移 = 1,1010
> - x = -1010 → [x]移 = 0,0110
#### 四种编码对比
| 编码 | 符号位 | 零的表示 | 范围 | 运算 |
|------|--------|----------|------|------|
| 原码 | 0正1负 | 两种 | $-(2^{n-1}-1) \sim +(2^{n-1}-1)$ | 复杂 |
| 补码 | 0正1负 | 唯一 | $-2^{n-1} \sim +(2^{n-1}-1)$ | 简单 |
| 反码 | 0正1负 | 两种 | $-(2^{n-1}-1) \sim +(2^{n-1}-1)$ | 较复杂 |
| 移码 | 1正0负 | 唯一 | $-2^{n-1} \sim +(2^{n-1}-1)$ | 便于比较 |
**转换关系**：
- 正数：原码 = 反码 = 补码
- 负数：补码 = 反码 + 1
---
## 6.2 定点数
### 6.2.1 定点表示
> [!info] 定义
> 小数点位置固定的数
**两种形式**：
```mermaid
graph LR
subgraph "定点整数"
A1[符号位] --> B1[数值部分] --> C1[小数点在最后]
end
subgraph "定点小数"
A2[符号位] --> B2[小数点] --> C2[数值部分]
end
```
**表示范围**：
| 类型 | 原码范围 | 补码范围 |
|------|----------|----------|
| 定点整数 | $-(2^{n-1}-1) \sim +(2^{n-1}-1)$ | $-2^{n-1} \sim +(2^{n-1}-1)$ |
| 定点小数 | $-(1-2^{-(n-1)}) \sim +(1-2^{-(n-1)})$ | $-1 \sim +(1-2^{-(n-1)})$ |
---
## 6.3 浮点数
### 6.3.1 浮点表示
> [!info] 定义
> 小数点位置可浮动的数，类似科学计数法。
**表示形式**：
$$N = S \times r^j$$
- S：尾数（小数）
- j：阶码（整数）
- r：基数（通常为2）
**存储格式**：
```mermaid
graph LR
subgraph "浮点数格式"
MS[阶符] --> E[阶码] --> M[数符] --> N[尾数]
end
```
### 6.3.2 浮点数规格化
> [!info] 目的
> 提高精度，使尾数最高位为有效数字。
**规格化条件**：
- 原码：尾数最高位为1
- 补码：尾数最高位与符号位相反
**左规**：尾数左移，阶码减1
**右规**：尾数右移，阶码加1
> [!example] 示例
> 非规格化：0.001011 × 2^5
> 左规后：0.1011 × 2^2
### 6.3.3 IEEE 754标准
**单精度（32位）格式**：
```mermaid
graph LR
subgraph "IEEE 754 单精度"
S[符号位1位] --> E[阶码8位] --> M[尾数23位]
end
```
**双精度（64位）格式**：
```mermaid
graph LR
subgraph "IEEE 754 双精度"
S[符号位1位] --> E[阶码11位] --> M[尾数52位]
end
```
**特点**：
- 隐含尾数最高位1
- 阶码用移码表示（偏置值127或1023）
- 尾数用原码表示
**数值计算**：
$$N = (-1)^S \times 1.M \times 2^{E-127}$$
> [!example] 示例
> 单精度：S=0, E=10000010, M=10010000000000000000000
> - 真值 = +1.1001 × 2^(130-127) = +1.1001 × 2^3 = +1100.1 = +12.5
### 6.3.4 浮点数范围
| 类型 | 最小正数 | 最大正数 | 溢出条件 |
|------|----------|----------|----------|
| 规格化 | $2^{-1} \times 2^{-2^{k-1}}$ | $(1-2^{-n}) \times 2^{2^{k-1}-1}$ | 阶码溢出 |
---
## 6.4 定点运算
### 6.4.1 移位运算
#### 算术移位
| 编码 | 左移 | 右移 |
|------|------|------|
| 原码 | 数值左移，右补0 | 数值右移，左补0 |
| 补码 | 数值左移，右补0 | 数值右移，左补符号位 |
| 反码 | 数值左移，右补0 | 数值右移，左补符号位 |
#### 逻辑移位
- 逻辑左移：高位移出，低位补0
- 逻辑右移：低位移出，高位补0
### 6.4.2 补码加减运算
> [!important] 核心公式
> $$[x+y]_{补} = [x]_{补} + [y]_{补}$$
> $$[x-y]_{补} = [x]_{补} + [-y]_{补}$$
**溢出判断**：
| 方法 | 条件 | 说明 |
|------|------|------|
| 单符号位 | 符号位进位与最高位进位异或 | 结果为1则溢出 |
| 双符号位 | 两个符号位不同 | 01正溢，10负溢 |
| 变形补码 | 双符号位 | 同上 |
> [!example] 示例
> 8位补码：x = +100, y = +100
> - [x]补 = 0,01100100
> - [y]补 = 0,01100100
> - [x+y]补 = 0,11001000（+200）
> - 结果正确，无溢出
### 6.4.3 乘法运算
#### 原码一位乘法
**算法**：
1. 符号位单独处理（异或）
2. 数值部分相乘
3. 部分累加
**流程**：
```mermaid
graph TB
A[初始化] --> B{乘数末位}
B -->|1| C[加被乘数]
B -->|0| D[加0]
C --> E[右移部分积]
D --> E
E --> F{n次?}
F -->|否| B
F -->|是| G[得到乘积]
```
#### 补码一位乘法（Booth算法）
**特点**：
- 符号位参与运算
- 最后一步不移位
- 根据乘数末两位决定操作
**操作规则**：
| 乘数末两位 | 操作 |
|------------|------|
| 00 | 部分积右移 |
| 01 | 加[x]补，右移 |
| 10 | 加[-x]补，右移 |
| 11 | 部分积右移 |
### 6.4.4 除法运算
#### 原码一位除法（恢复余数法）
**算法**：
1. 符号位单独处理
2. 被除数减除数
3. 若够减，商1；不够减，商0，恢复余数
4. 左移，重复
#### 加减交替法（不恢复余数法）
**特点**：
- 不恢复余数
- 根据余数符号决定下一步操作
**操作规则**：
| 余数符号 | 操作 | 商 |
|----------|------|-----|
| 正 | 左移，减除数 | 1 |
| 负 | 左移，加除数 | 0 |
---
## 6.5 浮点运算
### 6.5.1 浮点加减运算
**步骤**：
```mermaid
graph TB
A[对阶] --> B[尾数运算]
B --> C[规格化]
C --> D[舍入处理]
D --> E[溢出判断]
```
#### 1. 对阶
**目的**：使两个操作数的阶码相同
**方法**：小阶向大阶看齐，小阶尾数右移
> [!example] 示例
> x = 0.1101 × 2^3, y = 0.1011 × 2^1
> - 对阶：y = 0.001011 × 2^3
> - 尾数运算：0.1101 + 0.001011 = 0.111111
> - 结果：0.111111 × 2^3
#### 2. 尾数运算
- 按定点加减运算规则
- 使用双符号位
#### 3. 规格化
- 左规：尾数左移，阶码减1
- 右规：尾数右移，阶码加1
#### 4. 舍入处理
| 方法 | 规则 | 特点 |
|------|------|------|
| 0舍1入 | 移出位为1则入 | 误差小 |
| 恒置1 | 右移后末位置1 | 简单 |
#### 5. 溢出判断
- **上溢**：阶码大于最大值，溢出中断
- **下溢**：阶码小于最小值，置0
### 6.5.2 浮点乘除运算
**乘法**：
$$N_1 \times N_2 = (S_1 \times S_2) \times r^{j_1+j_2}$$
**除法**：
$$N_1 / N_2 = (S_1 / S_2) \times r^{j_1-j_2}$$
**步骤**：
1. 阶码加/减
2. 尾数乘/除
3. 规格化
4. 溢出判断
---
## 📝 本章小结
### 核心概念
1. **数据表示**：原码、补码、反码、移码
2. **定点数**：小数点位置固定
3. **浮点数**：小数点位置可变，类似科学计数法
4. **运算方法**：移位、加减、乘除
### 关键公式
- **补码加法**：$[x+y]_{补} = [x]_{补} + [y]_{补}$
- **补码减法**：$[x-y]_{补} = [x]_{补} + [-y]_{补}$
- **浮点数**：$N = S \times r^j$
- **IEEE 754**：$N = (-1)^S \times 1.M \times 2^{E-127}$
### 重点图示
> [!summary] 必须掌握的内容
> 1. 四种编码方式的转换关系
> 2. 补码加减运算及溢出判断
> 3. 浮点数加减运算步骤
> 4. IEEE 754标准格式
---
## 🧪 自测练习
### 概念题
1. 比较原码、补码、反码的特点。
2. 说明浮点数规格化的目的和方法。
3. 解释IEEE 754标准的格式。
### 计算题
1. 将十进制数转换为补码表示。
2. 进行补码加减运算并判断溢出。
3. 进行浮点数加减运算。
### 分析题
1. 说明Booth算法的原理和步骤。
2. 设计一个浮点加法器的数据通路。
---
## 🔗 相关链接
- [[05_输入输出系统]] - 上一章
- [[07_指令系统]] - 下一章
- [[08_CPU结构与功能]] - 运算器实现
- [[04_存储器]] - 数据存储
---
*本章难度：⭐⭐⭐⭐⭐ 困难*
*重要程度：⭐⭐⭐⭐⭐ 核心重点*

414
计算机组成原理/学习笔记/06_运算方法_补充版.md Normal file
View File

@@ -0,0 +1,414 @@
# 第6章 运算方法
> 📖 本章介绍计算机中数据的表示方法和算术运算，是课程的重点和难点。
> 🎯 重点理解补码运算和浮点数表示
---
## 📋 本章目录
- [[#6.1 无符号数和有符号数]]
- [[#6.2 定点数]]
- [[#6.3 浮点数]]
- [[#6.4 定点运算]]
- [[#6.5 浮点运算]]
- [[#本章小结]]
- [[#例题与解析]]
---
## 6.1 无符号数和有符号数
### 6.1.1 无符号数
> [!info] 定义
> 没有符号的数，所有位都表示数值。
**表示范围**（n位）：
$$0 \sim 2^n - 1$$
> [!example] 示例
> 16位无符号数：0 ~ 65535
无符号数就像你钱包里的钱，只有正数没有负数，范围从0到最大值。内存地址、数组索引、颜色值通常用无符号数表示。
### 6.1.2 有符号数
#### 机器数与真值
| 概念 | 定义 | 示例 |
|------|------|------|
| **真值** | 带正负号的数 | +1100, -1100 |
| **机器数** | 符号数字化的数 | 0,1100, 1,1100 |
**符号编码**：
- 0 表示正数
- 1 表示负数
真值用"+"和"-"表示正负，人容易理解但计算机不好处理；机器数用0和1表示正负，计算机容易处理但人不好理解。就像温度计用"+"和"-"表示零上和零下。
#### 1. 原码表示法
> [!info] 定义
> 符号位 + 数值的绝对值
**整数原码**：
$$[x]_{原} = \begin{cases} 0,x & 2^n > x \geq 0 \\ 2^n - x & 0 \geq x > -2^n \end{cases}$$
**小数原码**：
$$[x]_{原} = \begin{cases} x & 1 > x \geq 0 \\ 1 - x & 0 \geq x > -1 \end{cases}$$
> [!example] 示例
> - x = +1110 → [x]原 = 0,1110
> - x = -1110 → [x]原 = 1,1110
> - x = +0.1101 → [x]原 = 0.1101
> - x = -0.1101 → [x]原 = 1.1101
**零的表示**：
- [+0]原 = 0.0000
- [-0]原 = 1.0000
**特点**：表示简单易于转换，但加减运算复杂，零有两种表示。
原码用0表示正数1表示负数，后面跟着数值的绝对值。表示简单容易理解，但加减运算需要考虑符号，零有两种表示（+0和-0）。就像温度计用"+"和"-"表示零上和零下。
#### 2. 补码表示法
> [!important] 核心思想
> 用正数代替负数，将减法转换为加法。
**补数的概念**（时钟例子）：
- 时钟模为12
- -3 ≡ +9 (mod 12)
- 9 - 5 = 9 + 7 = 16 ≡ 4 (mod 12)
**整数补码**：
$$[x]_{补} = \begin{cases} 0,x & 2^n > x \geq 0 \\ 2^{n+1} + x & 0 > x \geq -2^n \end{cases}$$
**小数补码**：
$$[x]_{补} = \begin{cases} x & 1 > x \geq 0 \\ 2 + x & 0 > x \geq -1 \end{cases}$$
> [!example] 示例
> - x = +1010 → [x]补 = 0,1010
> - x = -1010 → [x]补 = 2^5 + (-1010) = 100000 - 1010 = 1,0110
> - x = +0.1001 → [x]补 = 0.1001
> - x = -0.1001 → [x]补 = 2 + (-0.1001) = 1.0111
**零的表示**：[+0]补 = [-0]补 = 0.0000（唯一表示）
**补码范围**（n位整数）：$-2^n \sim +(2^n - 1)$
> [!warning] 特殊值
> 8位补码：-128的补码为10000000，没有对应的原码
补码可以用时钟来理解：时钟模为12，-3小时相当于+9小时（因为-3+12=9）。补码就是用正数代替负数，将减法转换为加法。正数直接用原码表示，负数用模减去绝对值。
比如8位二进制：-10的补码是256-10=246=11110110。补码的优点是加减运算简单不需要考虑符号，零只有一种表示，范围比原码大1。缺点是表示不直观需要转换。所有整数运算都用补码。
#### 3. 反码表示法
**整数反码**：
$$[x]_{反} = \begin{cases} 0,x & 2^n > x \geq 0 \\ (2^{n+1}-1) + x & 0 \geq x > -2^n \end{cases}$$
**小数反码**：
$$[x]_{反} = \begin{cases} x & 1 > x \geq 0 \\ (2-2^{-n}) + x & 0 \geq x > -1 \end{cases}$$
> [!example] 示例
> - x = +1101 → [x]反 = 0,1101
> - x = -1101 → [x]反 = 1,0010
**零的表示**：
- [+0]反 = 0.0000
- [-0]反 = 1.1111
反码是补码减1，正数和原码相同，负数是原码除符号位外取反。是计算补码的中间步骤，某些旧计算机使用反码。
#### 4. 移码表示法
> [!info] 定义
> 移码 = 补码符号位取反
**用途**：便于比较大小（移码大的真值大）
**整数移码**：
$$[x]_{移} = 2^n + x \quad (-2^n \leq x < 2^n)$$
> [!example] 示例
> - x = +1010 → [x]移 = 1,1010
> - x = -1010 → [x]移 = 0,0110
移码把所有数都加上一个偏移量变成正数，便于比较大小。偏移量是128（8位移码），-128变成0，0变成128，+127变成255。浮点数的阶码通常用移码表示。
#### 四种编码对比
| 编码 | 符号位 | 零的表示 | 范围 | 运算 |
|------|--------|----------|------|------|
| 原码 | 0正1负 | 两种 | $-(2^{n-1}-1) \sim +(2^{n-1}-1)$ | 复杂 |
| 补码 | 0正1负 | 唯一 | $-2^{n-1} \sim +(2^{n-1}-1)$ | 简单 |
| 反码 | 0正1负 | 两种 | $-(2^{n-1}-1) \sim +(2^{n-1}-1)$ | 较复杂 |
| 移码 | 1正0负 | 唯一 | $-2^{n-1} \sim +(2^{n-1}-1)$ | 便于比较 |
**转换关系**：正数原码=反码=补码，负数补码=反码+1。
原码直接用符号位和绝对值，简单直观但运算复杂零有两种表示；补码用正数代替负数，运算简单零只有一种表示但表示不直观；反码是补码减1，是计算补码的中间步骤；移码补码符号位取反，便于比较大小。
---
## 6.2 定点数
### 6.2.1 定点表示
> [!info] 定义
> 小数点位置固定的数
**两种形式**：
```mermaid
graph LR
subgraph "定点整数"
A1[符号位] --> B1[数值部分] --> C1[小数点在最后]
end
subgraph "定点小数"
A2[符号位] --> B2[小数点] --> C2[数值部分]
end
```
**表示范围**：
| 类型 | 原码范围 | 补码范围 |
|------|----------|----------|
| 定点整数 | $-(2^{n-1}-1) \sim +(2^{n-1}-1)$ | $-2^{n-1} \sim +(2^{n-1}-1)$ |
| 定点小数 | $-(1-2^{-(n-1)}) \sim +(1-2^{-(n-1)})$ | $-1 \sim +(1-2^{-(n-1)})$ |
定点数用固定刻度的尺子：定点整数小数点在最后只表示整数，比如1010表示10；定点小数小数点在符号位后面只表示小数，比如0.1010表示0.625。
---
## 6.3 浮点数
### 6.3.1 浮点表示
> [!info] 定义
> 小数点位置可浮动的数，类似科学计数法。
**表示形式**：
$$N = S \times r^j$$
- S：尾数（小数）
- j：阶码（整数）
- r：基数（通常为2）
**存储格式**：
```mermaid
graph LR
subgraph "浮点数格式"
MS[阶符] --> E[阶码] --> M[数符] --> N[尾数]
end
```
浮点数就像科学计数法，把一个数表示成尾数乘以2的阶码次方。比如101.1=1.011×2²，可以表示很大或很小的数。
### 6.3.2 浮点数规格化
**规格化目的**：提高精度，使尾数的最高位为1。
**规格化方法**：
- **左规**：尾数左移，阶码减1
- **右规**：尾数右移，阶码加1
规格化前0.001011×2³尾数前面有0精度低，规格化后1.011×2⁰尾数最高位为1精度高。
### 6.3.3 IEEE 754标准
**单精度浮点数（32位）**：符号位1位，阶码8位（移码表示），尾数23位
**双精度浮点数（64位）**：符号位1位，阶码11位（移码表示），尾数52位
IEEE 754标准是浮点数的"国家标准"：单精度32位精度较低但速度快，用于大多数图形处理和科学计算；双精度64位精度高但速度慢，用于高精度科学计算和金融计算。
---
## 6.4 定点运算
### 6.4.1 移位运算
**算术移位**：左移相当于乘以2，右移相当于除以2
**逻辑移位**：左移高位移出低位补0，右移低位移出高位补0
算术移位像移动小数点，左移小数点向右移动数值变大，右移小数点向左移动数值变小。逻辑移位所有位向左或向右移动。1010左移1位变成10100（10→20）。
### 6.4.2 加减运算
**补码加减运算**：加法直接相加，减法减数变补码后相加
**溢出判断**：正溢出两个正数相加结果为负，负溢出两个负数相加结果为正
补码加减运算像时钟运算：9+7=16≡4(mod 12)，9-5=9+7=16≡4(mod 12)。127+1=-128（8位补码溢出）。
### 6.4.3 乘法运算
**原码乘法**：符号位单独处理，数值部分相乘
**补码乘法**：直接用补码相乘
乘法运算像重复加法：10×13=130，-6×-3=18。
### 6.4.4 除法运算
**原码除法**：符号位单独处理，数值部分相除
**补码除法**：直接用补码相除
除法运算像重复减法：10÷2=5，-6÷2=-3。
---
## 6.5 浮点运算
### 6.5.1 浮点加减运算
**步骤**：
1. **对阶**：使两个数的阶码相同
2. **尾数运算**：对阶后进行尾数加减
3. **规格化**：结果规格化
4. **舍入**：处理精度问题
5. **溢出判断**：检查阶码是否溢出
浮点加减运算像科学计数法加减：对阶使两个数的阶码相同，小阶向大阶看齐；尾数运算对阶后进行尾数加减；规格化使结果符合规格化要求；舍入处理精度问题；溢出判断检查阶码是否溢出。
1.01×2²+1.10×2¹：对阶变成1.01×2²+0.110×2²，尾数运算1.01+0.110=10.00，规格化10.00×2²=1.00×2³=8。
### 6.5.2 浮点乘除运算
**乘法**：阶码相加，尾数相乘，规格化
**除法**：阶码相减，尾数相除，规格化
浮点乘除运算像科学计数法乘除：10²×10³=10⁵，1.2×3.4=4.08，1.2×10²×3.4×10³=4.08×10⁵。
---
## 📝 本章小结
### 核心概念
1. **数据表示**：原码、补码、反码、移码
2. **定点数**：小数点位置固定
3. **浮点数**：小数点位置可浮动
4. **定点运算**：移位、加减、乘除
5. **浮点运算**：对阶、尾数运算、规格化
### 关键术语
| 术语 | 英文 | 含义 |
|------|------|------|
| 原码 | Sign-Magnitude | 符号位+绝对值 |
| 补码 | Two's Complement | 用正数代替负数 |
| 反码 | One's Complement | 补码减1 |
| 移码 | Excess Code | 补码符号位取反 |
| 浮点数 | Floating Point | 小数点位置可浮动 |
### 重点图示
> [!summary] 必须掌握的图
> 1. 四种编码的转换关系
> 2. 定点数和浮点数的表示
> 3. 浮点数加减运算流程
> 4. IEEE 754标准格式
---
## 🧪 例题与解析
### 例题1：补码计算
**题目**：计算8位补码的表示范围，并求-5的补码。
**答案**：
8位补码范围：-2⁷=-128到2⁷-1=127，即-128~127。
-5的补码：5的二进制00000101，取反11111010，加1得11111011。
这就像一个8位的时钟，范围-128到127，-5的补码是时钟倒退5小时。
### 例题2：浮点数表示
**题目**：将十进制数-0.75表示为IEEE 754单精度浮点数。
**答案**：
0.75=0.11(二进制)，-0.75=-0.11，规格化-1.1×2⁻¹。
符号位1（负数），阶码-1+127=126=01111110，尾数10000000000000000000000。
完整表示：1 01111110 10000000000000000000000。
### 例题3：补码加法
**题目**：用补码计算 5 + (-3)。
**答案**：
5的补码00000101，-3的补码11111101，相加：
```
00000101
+ 11111101
-----------
1 00000010
```
补码结果00000010，真值+2。5+(-3)=2✓
### 例题4：浮点数加法
**题目**：计算 1.01 × 2² + 1.10 × 2¹。
**答案**：
对阶：1.10×2¹=0.110×2²
尾数运算：1.010+0.110=10.000
规格化：10.000×2²=1.000×2³=8
验证：1.01×2²=5，1.10×2¹=3，5+3=8✓
### 例题5：溢出判断
**题目**：判断8位补码运算 127 + 1 是否溢出。
**答案**：
127的补码01111111，1的补码00000001，相加得10000000。
两个正数相加结果为负数（10000000是-128的补码），发生正溢出。
真正结果128，实际结果-128，溢出。
---
## ⚡ 知识点速记卡
> 考前快速过一遍，30秒回忆整章核心
**四种编码速记**：原码（符号+绝对值，零有两种）、补码（正代负，零唯一，运算最简单）、反码（补码-1，过渡用）、移码（补码符号取反，便于比较大小）。
**正数**：原码=反码=补码。**负数**：补码=反码+1。口诀：正数不变，负数取反加1。
**补码范围**（n位）：-2^(n-1) ~ +(2^(n-1)-1)。8位补码：-128~127。-128没有对应原码！
**补码加减运算**：加法直接加，减法变补码后加。溢出判断：两个正数相加得负数（正溢出），两个负数相加得正数（负溢出）。
**定点数**：小数点位置固定。定点整数（小数点在末尾）、定点小数（小数点在符号位后）。
**浮点数 = 尾数 × 2^阶码**，类似科学计数法。规格化：尾数最高位为1，左规尾数左移阶码减1，右规尾数右移阶码加1。
**IEEE 754单精度（32位）**：1位符号 + 8位阶码（移码，偏移127）+ 23位尾数。阶码全0和全1有特殊含义。
**浮点加减五步**：对阶（小阶向大阶看齐）→ 尾数运算 → 规格化 → 舍入 → 溢出判断。
**移位运算**：算术左移=×2，算术右移=÷2。逻辑移位补0，算术移位保持符号位。
---
## 🔗 相关链接
- [[00_计算机组成原理学习指南]] - 返回主目录
- [[05_输入输出系统]] - 上一章
- [[07_指令系统]] - 下一章
- [[08_CPU结构与功能]] - CPU相关内容
---
*本章难度：⭐⭐⭐⭐⭐ 困难*
*重要程度：⭐⭐⭐⭐⭐ 重点*

475
计算机组成原理/学习笔记/07_指令系统.md Normal file
View File

@@ -0,0 +1,475 @@
# 第7章 指令系统
> 📖 本章介绍机器指令系统的分类、寻址方式和指令格式设计。
> 🎯 重点理解寻址方式和指令格式设计
---
## 📋 本章目录
- [[#7.1 机器指令]]
- [[#7.2 操作数类型和操作类型]]
- [[#7.3 寻址方式]]
- [[#7.4 指令格式]]
- [[#7.5 RISC技术]]
- [[#本章小结]]
---
## 7.1 机器指令
### 7.1.1 指令的一般格式
> [!info] 定义
> 机器指令是计算机能识别和执行的基本命令，由操作码和地址码组成。
```mermaid
graph LR
subgraph "指令格式"
OP[操作码] --> ADDR[地址码]
end
```
#### 操作码
**功能**：指明指令要完成的操作
**长度**：
- **固定长度**：便于硬件设计，译码快
- **可变长度**：节省空间，译码复杂
#### 地址码
**功能**：指出操作数地址、结果地址、下条指令地址
**格式分类**：
```mermaid
graph TB
A[指令格式] --> B[四地址指令]
A --> C[三地址指令]
A --> D[二地址指令]
A --> E[一地址指令]
A --> F[零地址指令]
```
| 格式 | 地址字段 | 操作 | 访存次数 |
|------|----------|------|----------|
| 四地址 | A1, A2, A3, A4 | (A1)OP(A2)→A3 | 4次 |
| 三地址 | A1, A2, A3 | (A1)OP(A2)→A3 | 4次 |
| 二地址 | A1, A2 | (A1)OP(A2)→A1 | 4次 |
| 一地址 | A1 | ACCOP(A1)→ACC | 2次 |
| 零地址 | 无 | 栈操作 | 0-2次 |
> [!example] 示例
> 四地址指令：OP A1 A2 A3 A4
> - (A1) OP (A2) → A3
> - 下条指令地址 = A4
### 7.1.2 扩展操作码技术
> [!info] 目的
> 在指令字长固定的情况下，增加指令种类。
**原理**：操作码长度随地址数减少而增加
```mermaid
graph TB
subgraph "扩展操作码示例（16位指令）"
A["4位操作码<br/>15条三地址指令"] --> B["8位操作码<br/>15条二地址指令"]
B --> C["12位操作码<br/>15条一地址指令"]
C --> D["16位操作码<br/>16条零地址指令"]
end
```
**设计原则**：
- 使用频度高的指令用短操作码
- 使用频度低的指令用长操作码
- 为扩展留有余地
---
## 7.2 操作数类型和操作类型
### 7.2.1 操作数类型
| 类型 | 说明 | 示例 |
|------|------|------|
| 地址 | 无符号整数 | 指向存储器位置 |
| 数值 | 定点数、浮点数 | 算术运算 |
| 字符 | ASCII码 | 文本处理 |
| 逻辑数 | 位串 | 逻辑运算 |
### 7.2.2 操作类型
#### 数据传送类
| 指令 | 功能 | 示例 |
|------|------|------|
| MOV | 数据传送 | MOV AX, BX |
| LOAD | 从存储器取数 | LOAD R1, [addr] |
| STORE | 存数到存储器 | STORE [addr], R1 |
| PUSH/POP | 栈操作 | PUSH AX |
#### 算术逻辑类
| 指令 | 功能 | 示例 |
|------|------|------|
| ADD/SUB | 加/减 | ADD AX, BX |
| MUL/DIV | 乘/除 | MUL BX |
| AND/OR/NOT | 逻辑运算 | AND AX, BX |
| CMP | 比较 | CMP AX, BX |
| SHL/SHR | 移位 | SHL AX, 1 |
#### 控制转移类
| 指令 | 功能 | 示例 |
|------|------|------|
| JMP | 无条件跳转 | JMP addr |
| JZ/JNZ | 条件跳转 | JZ addr |
| CALL | 调用子程序 | CALL addr |
| RET | 返回 | RET |
| INT | 中断 | INT 21H |
---
## 7.3 寻址方式
> [!info] 定义
> 寻址方式是指令中如何给出操作数地址或操作数的方式。
### 7.3.1 指令寻址
#### 顺序寻址
```mermaid
graph LR
PC[PC] --> |"PC+1"| NEXT[下一条指令]
```
#### 跳跃寻址
```mermaid
graph LR
PC[PC] --> |"JMP addr"| TARGET[目标指令]
```
### 7.3.2 数据寻址
**指令格式**：
```mermaid
graph LR
subgraph "数据寻址格式"
OP[操作码] --> MOD[寻址特征] --> ADDR[形式地址]
end
```
**有效地址**：$EA = f(寻址方式, 形式地址)$
#### 常见寻址方式
##### 1. 立即寻址
> [!info] 特点
> 操作数直接在指令中
**格式**：OP #立即数
**有效地址**：$EA = 指令地址 + 1$（操作数在指令中）
**优点**：速度快，不需要访存
**缺点**：操作数范围受地址字段限制
##### 2. 直接寻址
> [!info] 特点
> 地址字段直接给出操作数地址
**格式**：OP A
**有效地址**：$EA = A$
**优点**：简单，只需一次访存
**缺点**：寻址范围受地址字段限制
##### 3. 间接寻址
> [!info] 特点
> 地址字段给出的是操作数地址的地址
**格式**：OP (A)
**有效地址**：$EA = (A)$
**优点**：寻址范围大
**缺点**：多次访存，速度慢
```mermaid
graph LR
A[形式地址A] --> |"第一次访存"| B[地址B]
B --> |"第二次访存"| C[操作数]
```
##### 4. 寄存器寻址
> [!info] 特点
> 操作数在寄存器中
**格式**：OP R
**有效地址**：$EA = R$
**优点**：速度快，不需要访存
**缺点**：寄存器数量有限
##### 5. 寄存器间接寻址
> [!info] 特点
> 寄存器中存放的是操作数的地址
**格式**：OP (R)
**有效地址**：$EA = (R)$
**优点**：寻址范围大，只需一次访存
**缺点**：需要一次访存
##### 6. 偏移寻址
###### 基址寻址
**格式**：OP A，基址寄存器BR
**有效地址**：$EA = (BR) + A$
**特点**：
- 便于程序重定位
- 基址寄存器内容不变
- 形式地址可变
###### 变址寻址
**格式**：OP A，变址寄存器IX
**有效地址**：$EA = (IX) + A$
**特点**：
- 便于数组操作
- 变址寄存器内容可变
- 形式地址不变
> [!example] 数组访问示例
> 访问数组元素：$EA = (IX) + A$
> - A：数组首地址
> - IX：元素下标
> - 每次IX+1，访问下一个元素
###### 相对寻址
**格式**：OP A
**有效地址**：$EA = (PC) + A$
**特点**：
- 程序浮动
- A是相对于PC的偏移量
##### 7. 堆栈寻址
**格式**：PUSH/POP 操作数
**有效地址**：
- PUSH：先SP-1，再存数
- POP：先取数，再SP+1
**特点**：后进先出（LIFO）
#### 寻址方式对比
| 寻址方式 | 有效地址 | 访存次数 | 优点 | 缺点 |
|----------|----------|----------|------|------|
| 立即寻址 | 操作数在指令中 | 0 | 速度快 | 范围小 |
| 直接寻址 | EA=A | 1 | 简单 | 范围小 |
| 间接寻址 | EA=(A) | 2+ | 范围大 | 速度慢 |
| 寄存器寻址 | EA=R | 0 | 速度最快 | 数量有限 |
| 寄存器间接 | EA=(R) | 1 | 范围大 | 需要访存 |
| 基址寻址 | EA=(BR)+A | 1 | 便于重定位 | 需要基址寄存器 |
| 变址寻址 | EA=(IX)+A | 1 | 便于数组操作 | 需要变址寄存器 |
| 相对寻址 | EA=(PC)+A | 1 | 程序浮动 | 范围有限 |
| 堆栈寻址 | 栈顶 | 0-1 | 自动管理 | 只能栈操作 |
---
## 7.4 指令格式
### 7.4.1 指令格式设计考虑因素
| 因素 | 考虑内容 |
|------|----------|
| 指令字长 | 固定/可变，长度选择 |
| 操作码 | 固定/可变，长度分配 |
| 地址码 | 地址个数，寻址方式 |
| 数据类型 | 支持的数据类型 |
| 寻址方式 | 提供哪些寻址方式 |
### 7.4.2 指令字长
**固定字长**：
- 优点：取指时间固定，硬件简单
- 缺点：浪费空间
**可变字长**：
- 优点：节省空间
- 缺点：取指时间不固定
### 7.4.3 指令格式举例
#### IBM 370指令格式
```mermaid
graph LR
subgraph "IBM 370 指令格式"
OP[操作码8位] --> R1[寄存器1] --> R2[寄存器2] --> B2[基址寄存器] --> D2[位移量]
end
```
**特点**：
- 固定操作码长度（8位）
- 基址+位移寻址
- 16个通用寄存器
#### Intel 8086指令格式
```mermaid
graph LR
subgraph "Intel 8086 指令格式"
OP[操作码] --> MOD[寻址方式] --> R/M[寄存器/存储器] --> DISP[位移量]
end
```
**特点**：
- 可变操作码长度
- 多种寻址方式
- 8个通用寄存器
### 7.4.4 指令系统设计原则
1. **完备性**：指令功能完整
2. **规整性**：指令格式统一
3. **对称性**：操作对称
4. **可扩充性**：便于扩展
5. **兼容性**：向上兼容
---
## 7.5 RISC技术
### 7.5.1 RISC与CISC
| 特性 | CISC | RISC |
|------|------|------|
| 指令数量 | 多（几百条） | 少（几十条） |
| 指令长度 | 可变 | 固定 |
| 寻址方式 | 多种 | 少数几种 |
| 执行时间 | 不固定 | 固定（一个周期） |
| 访存方式 | 多种指令可访存 | 只有LOAD/STORE |
| 控制方式 | 微程序 | 硬布线 |
| 优化目标 | 缩短程序长度 | 提高执行速度 |
### 7.5.2 RISC特点
**主要特点**：
1. **指令数量少**：只包含常用指令
2. **指令长度固定**：简化取指和译码
3. **寻址方式少**：简化寻址逻辑
4. **只有LOAD/STORE访存**：简化数据通路
5. **大量寄存器**：减少访存次数
6. **硬布线控制**：提高执行速度
7. **流水线技术**：提高并行度
8. **优化编译**：充分利用硬件
### 7.5.3 RISC优势
| 优势 | 说明 |
|------|------|
| 速度快 | 指令执行时间固定，便于流水线 |
| 硬件简单 | 控制逻辑简单，成本低 |
| 设计周期短 | 指令少，验证容易 |
| 功耗低 | 逻辑简单，功耗小 |
### 7.5.4 RISC vs CISC对比
```mermaid
graph TB
subgraph "CISC"
A1[复杂指令] --> B1[微程序执行]
B1 --> C1[多周期]
end
subgraph "RISC"
A2[简单指令] --> B2[硬布线执行]
B2 --> C2[单周期]
C2 --> D2[流水线]
end
```
---
## 📝 本章小结
### 核心概念
1. **指令格式**：操作码 + 地址码
2. **寻址方式**：立即、直接、间接、寄存器、基址、变址、相对、堆栈
3. **指令系统设计**：完备性、规整性、可扩充性
4. **RISC技术**：简化指令，提高速度
### 关键公式
- **有效地址**：$EA = f(寻址方式, 形式地址)$
- **基址寻址**：$EA = (BR) + A$
- **变址寻址**：$EA = (IX) + A$
- **相对寻址**：$EA = (PC) + A$
### 重点图示
> [!summary] 必须掌握的内容
> 1. 指令格式分类（四地址到零地址）
> 2. 扩展操作码技术
> 3. 各种寻址方式的计算方法
> 4. RISC与CISC的区别
---
## 🧪 自测练习
### 概念题
1. 比较各种指令格式的特点。
2. 说明扩展操作码技术的原理。
3. 解释RISC技术的主要特点。
### 计算题
1. 给定指令字长和操作数地址，设计扩展操作码。
2. 计算各种寻址方式下的有效地址。
### 分析题
1. 设计一个简单的指令系统。
2. 分析RISC和CISC的优缺点。
---
## 🔗 相关链接
- [[06_运算方法]] - 上一章
- [[08_CPU结构与功能]] - 下一章
- [[10_控制单元设计]] - 指令执行
- [[04_存储器]] - 存储器访问
---
*本章难度：⭐⭐⭐⭐ 中等偏难*
*重要程度：⭐⭐⭐⭐ 重点*

323
计算机组成原理/学习笔记/07_指令系统_补充版.md Normal file
View File

@@ -0,0 +1,323 @@
# 第7章 指令系统
> 📖 本章介绍机器指令系统的分类、寻址方式和指令格式设计。
> 🎯 重点理解寻址方式和指令格式设计
---
## 📋 本章目录
- [[#7.1 机器指令]]
- [[#7.2 操作数类型和操作类型]]
- [[#7.3 寻址方式]]
- [[#7.4 指令格式]]
- [[#7.5 RISC技术]]
- [[#本章小结]]
- [[#例题与解析]]
---
## 7.1 机器指令
### 7.1.1 指令的一般格式
> [!info] 定义
> 机器指令是计算机能识别和执行的基本命令，由操作码和地址码组成。
```mermaid
graph LR
subgraph "指令格式"
OP[操作码] --> ADDR[地址码]
end
```
#### 操作码
**功能**：指明指令要完成的操作
**长度**：
- **固定长度**：便于硬件设计，译码快
- **可变长度**：节省空间，译码复杂
操作码就像菜谱上的"动作"，告诉厨师要做什么（炒、煮、蒸、烤）。固定长度每个动作都用相同长度的编码，可变长度常用动作用短编码不常用动作用长编码。
#### 地址码
**功能**：指出操作数地址、结果地址、下条指令地址
**格式分类**：
```mermaid
graph TB
A[指令格式] --> B[四地址指令]
A --> C[三地址指令]
A --> D[二地址指令]
A --> E[一地址指令]
A --> F[零地址指令]
```
| 格式 | 地址字段 | 操作 | 访存次数 |
|------|----------|------|----------|
| 四地址 | A1, A2, A3, A4 | (A1)OP(A2)→A3 | 4次 |
| 三地址 | A1, A2, A3 | (A1)OP(A2)→A3 | 4次 |
| 二地址 | A1, A2 | (A1)OP(A2)→A1 | 4次 |
| 一地址 | A1 | ACCOP(A1)→ACC | 2次 |
| 零地址 | 无 | 栈操作 | 0-2次 |
地址码就像菜谱上的"材料"：四地址指令把A1和A2的数相加结果存到A3，下条指令在A4；三地址指令把A1和A2的数相加结果存到A3；二地址指令把A1和A2的数相加结果存到A1；一地址指令把ACC和A1的数相加结果存到ACC；零地址指令弹出栈顶两个数相加结果压入栈。
### 7.1.2 扩展操作码技术
> [!info] 目的
> 在指令字长固定的情况下，增加指令种类。
**原理**：操作码长度随地址数减少而增加
```mermaid
graph TB
subgraph "扩展操作码示例（16位指令）"
A["4位操作码<br/>15条三地址指令"] --> B["8位操作码<br/>15条二地址指令"]
B --> C["12位操作码<br/>15条一地址指令"]
C --> D["16位操作码<br/>16条零地址指令"]
end
```
**设计原则**：
- 使用频度高的指令用短操作码
- 使用频度低的指令用长操作码
- 为扩展留有余地
扩展操作码就像邮政编码系统：短操作码常用指令用短编码节省空间，长操作码不常用指令用长编码种类多。4位操作码15条三地址指令（1111保留），8位操作码15条二地址指令，12位操作码15条一地址指令，16位操作码16条零地址指令。
---
## 7.2 操作数类型和操作类型
### 7.2.1 操作数类型
| 类型 | 说明 | 示例 |
|------|------|------|
| 地址 | 无符号整数 | 指向存储器位置 |
| 数值 | 定点数、浮点数 | 算术运算 |
| 字符 | ASCII码 | 文本处理 |
| 逻辑数 | 逻辑运算 | 位操作 |
地址是无符号整数指向存储器位置，用于寻址操作；数值是定点数或浮点数用于算术运算；字符是ASCII码用于文本处理；逻辑数用于逻辑运算和位操作。
### 7.2.2 操作类型
**数据传送**：LOAD（从存储器取数据到寄存器）、STORE（从寄存器存数据到存储器）
**算术逻辑运算**：ADD（加法）、SUB（减法）、AND（逻辑与）、OR（逻辑或）
**移位操作**：SHL（逻辑左移）、SHR（逻辑右移）、SAL（算术左移）、SAR（算术右移）
**转移操作**：JMP（无条件转移）、JZ（条件转移）、CALL（调用子程序）、RET（返回）
**输入输出**：IN（从I/O端口读数据）、OUT（向I/O端口写数据）
数据传送像从仓库取材料到工作台；算术逻辑运算像把两个数加起来或相减；移位操作像所有位向左移动；转移操作像跳转到指定位置；输入输出像从外部设备读数据。
---
## 7.3 寻址方式
### 7.3.1 指令寻址
**顺序寻址**：PC = PC + 1，按顺序执行指令
**跳跃寻址**：PC = 跳转地址，跳转到指定地址执行
指令寻址像找下一条指令的方式：顺序寻址按顺序执行下一条指令，跳跃寻址跳转到指定地址执行。
### 7.3.2 数据寻址
**立即寻址**：操作数在指令中，比如MOV A, #5（把5存到A）。东西就在你手里，速度快不需要访问内存，只能用于常数。
**直接寻址**：操作数地址在指令中，比如MOV A, [1000]（把地址1000的数存到A）。东西在仓库的某个位置，简单直接访问，地址范围有限。
**间接寻址**：操作数地址的地址在指令中，比如MOV A, [[1000]]。仓库里有一张纸条告诉你东西在哪里，灵活可以动态改变地址，但速度慢需要多次访问内存。
**寄存器寻址**：操作数在寄存器中，比如MOV A, R1（把R1的数存到A）。东西就在你手边的盒子里，速度最快不需要访问内存，寄存器数量有限。
**寄存器间接寻址**：操作数地址在寄存器中，比如MOV A, [R1]。盒子里有一张纸条告诉你东西在哪里，灵活可以动态改变地址，需要访问内存。
**基址寻址**：操作数地址 = 基址 + 偏移量，比如MOV A, [BASE + 100]。东西在仓库的某个区域，用区域号+偏移量定位，适合程序重定位。
**变址寻址**：操作数地址 = 变址 + 偏移量，比如MOV A, [INDEX + 100]。东西在仓库的某个位置，用变址+偏移量定位，适合数组访问。
**相对寻址**：操作数地址 = PC + 偏移量，比如JMP +10（跳转到PC+10的位置）。东西在当前位置的某个偏移位置，适合相对跳转。
---
## 7.4 指令格式
### 7.4.1 指令格式设计原则
**设计原则**：
1. **规整性**：指令长度对齐，便于译码
2. **高效性**：常用指令短，不常用指令长
3. **兼容性**：保持向后兼容
4. **扩展性**：留有扩展空间
指令格式设计就像设计邮票：规整性指令长度对齐便于译码，高效性常用指令短不常用指令长，兼容性新处理器能运行旧程序，扩展性保留一些编码用于未来扩展。
### 7.4.2 指令格式举例
**x86指令格式**：变长指令，格式复杂，代码密度高兼容性好，译码复杂。
**ARM指令格式**：固定长度指令，格式简单，译码简单速度快，代码密度低。
---
## 7.5 RISC技术
### 7.5.1 RISC与CISC对比
| 特性 | RISC | CISC |
|------|------|------|
| 指令数量 | 少 | 多 |
| 指令长度 | 固定 | 可变 |
| 寻址方式 | 简单 | 复杂 |
| 指令周期 | 单周期 | 多周期 |
| 流水线 | 支持 | 部分支持 |
| 编译器 | 复杂 | 简单 |
RISC（精简指令集）指令少简单速度快，容易实现流水线，但编译器复杂代码密度低；CISC（复杂指令集）指令多复杂功能强，编译器简单代码密度高，但难以实现流水线速度慢。
ARM处理器（手机）、MIPS处理器（嵌入式）是RISC；x86处理器（个人电脑）是CISC。
### 7.5.2 RISC特点
**主要特点**：
1. **指令数量少**：通常只有几十条指令
2. **指令长度固定**：所有指令长度相同
3. **寻址方式简单**：只有几种简单的寻址方式
4. **单周期执行**：大多数指令在一个周期内完成
5. **流水线支持**：容易实现流水线
6. **大量寄存器**：通常有32个以上寄存器
7. **硬布线控制**：用硬布线实现控制单元
指令数量少容易实现速度快但功能有限；指令长度固定译码简单容易实现流水线但代码密度低；寻址方式简单译码简单速度快但灵活性差；单周期执行速度快容易实现流水线但某些复杂指令需要多个周期；流水线支持提高吞吐率但需要处理流水线冲突；大量寄存器减少访存次数速度快但增加硬件成本；硬布线控制速度快但不灵活难以修改。
---
## 📝 本章小结
### 核心概念
1. **指令格式**：操作码 + 地址码
2. **寻址方式**：立即寻址、直接寻址、间接寻址等
3. **指令类型**：数据传送、算术逻辑、移位、转移、输入输出
4. **RISC技术**：精简指令集，速度快
### 关键术语
| 术语 | 英文 | 含义 |
|------|------|------|
| 指令 | Instruction | 机器指令 |
| 操作码 | Operation Code | 指明操作类型 |
| 地址码 | Address Code | 指明操作数地址 |
| 寻址方式 | Addressing Mode | 找到操作数的方式 |
| RISC | Reduced Instruction Set Computer | 精简指令集计算机 |
| CISC | Complex Instruction Set Computer | 复杂指令集计算机 |
### 重点图示
> [!summary] 必须掌握的图
> 1. 指令格式图
> 2. 各种寻址方式图
> 3. 扩展操作码图
> 4. RISC与CISC对比图
---
## 🧪 例题与解析
### 例题1：指令格式设计
**题目**：设计一个16位指令系统，要求支持15条三地址指令、15条二地址指令、15条一地址指令、16条零地址指令。
**答案**：
三地址指令：4位操作码（1111保留），3个×4位=12位地址码，指令数2⁴-1=15条。
二地址指令：8位操作码（1111xxxx，xxxx≠1111），2个×4位=8位地址码，指令数15条。
一地址指令：12位操作码（1111xxxxxxxx，xxxxxxxx≠11111111），1个×4位=4位地址码，指令数15条。
零地址指令：16位操作码（1111xxxxxxxxxxxx），0位地址码，指令数16条。
### 例题2：寻址方式分析
**题目**：分析以下指令的寻址方式：
1. MOV A, #5
2. MOV A, [1000]
3. MOV A, R1
4. MOV A, [R1]
5. MOV A, [BASE + 100]
**答案**：
1. MOV A, #5：立即寻址，操作数5在指令中，速度快不需要访问内存。
2. MOV A, [1000]：直接寻址，操作数在地址1000，简单直接访问。
3. MOV A, R1：寄存器寻址，操作数在寄存器R1，速度最快不需要访问内存。
4. MOV A, [R1]：寄存器间接寻址，R1指向的地址的数，灵活可以动态改变地址。
5. MOV A, [BASE + 100]：基址寻址，BASE+100的数，适合程序重定位。
### 例题3：RISC与CISC比较
**题目**：比较RISC和CISC的特点。
**答案**：
RISC指令数量少（几十条）、指令长度固定、寻址方式简单、单周期执行、支持流水线、编译器复杂、寄存器多、硬布线控制；CISC指令数量多（几百条）、指令长度可变、寻址方式复杂、多周期执行、部分支持流水线、编译器简单、寄存器少、微程序控制。
RISC像精简工具，工具少简单速度快，容易使用效率高但功能有限；CISC像复杂工具，工具多复杂功能强，功能强大使用方便但使用复杂效率低。
### 例题4：扩展操作码设计
**题目**：设计一个12位指令系统，要求支持15条二地址指令、15条一地址指令、16条零地址指令。
**答案**：
二地址指令：4位操作码（1111保留），2个×4位=8位地址码，指令数2⁴-1=15条。
一地址指令：8位操作码（1111xxxx，xxxx≠1111），1个×4位=4位地址码，指令数15条。
零地址指令：12位操作码（1111xxxxxxxx），0位地址码，指令数16条。
### 例题5：寻址方式计算
**题目**：某计算机有16位地址线，8位数据线，采用直接寻址方式，求寻址范围。
**答案**：
16位地址线可以表示2¹⁶=65536个地址，即有65536个存储单元。8位数据线表示每个单元存8位数据（1字节），总容量65536×8位=64KB。
这就像一个仓库有65536个格子，每个格子能放8个鸡蛋，总容量就是64KB。
---
## ⚡ 知识点速记卡
> 考前快速过一遍，30秒回忆整章核心
**指令 = 操作码 + 地址码**。操作码指明做什么，地址码指明操作数在哪。
**地址码个数**：四地址（A1 OP A2 → A3，下条在A4）、三地址（→A3）、二地址（→A1）、一地址（ACC OP A1 → ACC）、零地址（栈操作）。
**扩展操作码**：地址数越少，操作码越长，指令种类越多。常用指令用短操作码，不常用指令用长操作码。
**七种寻址方式**：立即（数在指令里，最快）、直接（地址在指令里）、间接（地址指向的位置存着真正地址）、寄存器（数在寄存器，最快之一）、寄存器间接（寄存器里存地址）、基址（基址+偏移，适合重定位）、变址（变址+偏移，适合数组）、相对（PC+偏移，适合跳转）。
**RISC vs CISC**：RISC指令少、固定长度、单周期、流水线友好、硬布线控制（ARM/MIPS）；CISC指令多、可变长度、多周期、微程序控制（x86）。
**指令格式设计**：规整性（长度对齐）、高效性（常用指令短）、兼容性（向后兼容）、扩展性（留余地）。
---
## 🔗 相关链接
- [[00_计算机组成原理学习指南]] - 返回主目录
- [[06_运算方法]] - 上一章
- [[08_CPU结构与功能]] - 下一章
- [[09_控制单元功能]] - 控制单元相关内容
---
*本章难度：⭐⭐⭐⭐ 中等*
*重要程度：⭐⭐⭐⭐ 重要*

423
计算机组成原理/学习笔记/08_CPU结构与功能.md Normal file
View File

@@ -0,0 +1,423 @@
# 第8章 CPU的结构和功能
> 📖 本章介绍CPU的功能、内部结构和指令执行过程。
> 🎯 重点理解CPU组成和指令周期
---
## 📋 本章目录
- [[#8.1 CPU的结构]]
- [[#8.2 指令周期]]
- [[#8.3 指令流水]]
- [[#8.4 中断系统]]
- [[#本章小结]]
---
## 8.1 CPU的结构
### 8.1.1 CPU的功能
> [!info] 核心功能
> CPU负责协调并控制计算机各部件执行程序的指令序列。
**基本功能**：
| 功能 | 说明 |
|------|------|
| **指令控制** | 控制程序的顺序执行 |
| **操作控制** | 产生完成每条指令所需的控制命令 |
| **时间控制** | 对各种操作加以时间上的控制 |
| **数据加工** | 对数据进行算术运算和逻辑运算 |
| **中断处理** | 处理异常情况和特殊请求 |
### 8.1.2 CPU结构框图
```mermaid
graph TB
subgraph "CPU内部结构"
subgraph "运算器"
ALU[ALU<br/>算术逻辑单元]
ACC[ACC<br/>累加寄存器]
PSW[PSW<br/>程序状态字]
REG[通用寄存器组]
end
subgraph "控制器"
CU[CU<br/>控制单元]
PC[PC<br/>程序计数器]
IR[IR<br/>指令寄存器]
MAR[MAR<br/>存储器地址寄存器]
MDR[MDR<br/>存储器数据寄存器]
end
end
ALU <--> |"数据"| REG
ALU <--> |"数据"| ACC
CU --> |"控制信号"| ALU
CU --> |"控制信号"| REG
PC --> |"地址"| MAR
IR --> |"指令"| CU
MAR <--> |"地址"| MEM[主存]
MDR <--> |"数据"| MEM
style ALU fill:#ff9999
style CU fill:#99ccff
style PC fill:#99ff99
style IR fill:#ffcc99
```
### 8.1.3 CPU的寄存器
#### 用户可见寄存器
| 寄存器类型 | 功能 | 示例 |
|------------|------|------|
| **通用寄存器** | 可编程使用，存放操作数 | AX, BX, CX, DX |
| **数据寄存器** | 存放操作数 | 数据寄存器 |
| **地址寄存器** | 存放地址 | 基址寄存器、变址寄存器 |
| **条件码寄存器** | 存放运算结果状态 | Z（零）、C（进位）、S（符号）、O（溢出） |
#### 控制和状态寄存器
| 寄存器 | 功能 | 可见性 |
|--------|------|--------|
| **PC** | 程序计数器，存放现行指令地址 | 用户可见 |
| **IR** | 指令寄存器，存放当前指令 | 用户不可见 |
| **MAR** | 存储器地址寄存器 | 用户不可见 |
| **MDR** | 存储器数据寄存器 | 用户不可见 |
| **PSW** | 程序状态字寄存器 | 部分可见 |
**PC（程序计数器）**：
- 存放现行指令地址
- 具有计数功能（PC+1→PC）
- 遇到转移指令时可被修改
**IR（指令寄存器）**：
- 存放当前正在执行的指令
- 包含操作码和地址码
- 操作码送CU译码
**MAR（存储器地址寄存器）**：
- 存放将被访问的存储单元地址
- 位数与地址总线宽度相同
**MDR（存储器数据寄存器）**：
- 存放欲存入存储器的数据或从存储器读出的数据
- 位数与数据总线宽度相同
### 8.1.4 数据通路
```mermaid
graph TB
subgraph "CPU内部数据通路"
PC[PC] --> |"地址"| MAR[MAR]
MAR --> |"地址"| MEM[主存]
MEM --> |"数据"| MDR[MDR]
MDR --> |"指令"| IR[IR]
MDR --> |"数据"| ALU[ALU]
REG[通用寄存器] <--> |"数据"| ALU
ALU --> |"结果"| REG
ALU --> |"状态"| PSW[PSW]
end
```
---
## 8.2 指令周期
### 8.2.1 指令周期的基本概念
> [!info] 定义
> 指令周期是取出一条指令并执行这条指令的时间。
**组成**：
```mermaid
graph LR
A[指令周期] --> B[取指周期]
A --> C[执行周期]
B --> B1[取指令]
B --> B2[分析指令]
C --> C1[执行指令]
```
### 8.2.2 指令周期流程
```mermaid
graph TB
START[开始] --> FETCH[取指周期]
FETCH --> DECODE[分析指令]
DECODE --> EXEC[执行周期]
EXEC --> CHECK{中断?}
CHECK -->|是| INT[中断处理]
CHECK -->|否| NEXT[取下一条指令]
INT --> NEXT
NEXT --> FETCH
```
### 8.2.3 取指周期
**操作序列**：
1. PC → MAR（地址送MAR）
2. MAR → 地址总线 → 主存（地址送主存）
3. CU发读命令（控制信号）
4. 主存 → 数据总线 → MDR（指令送MDR）
5. MDR → IR（指令送IR）
6. PC + 1 → PC（程序计数器加1）
7. OP(IR) → CU（操作码送CU译码）
```mermaid
sequenceDiagram
participant PC
participant MAR
participant MEM as 主存
participant MDR
participant IR
participant CU
PC->>MAR: PC → MAR
MAR->>MEM: 地址送主存
CU->>MEM: 发读命令
MEM->>MDR: 指令送MDR
MDR->>IR: 指令送IR
Note over PC: PC+1 → PC
IR->>CU: 操作码送CU
```
### 8.2.4 执行周期
**不同指令的执行周期**：
| 指令类型 | 执行操作 |
|----------|----------|
| **取数指令** | MAR → 主存 → MDR → 寄存器 |
| **存数指令** | 寄存器 → MDR → 主存 |
| **加法指令** | 取操作数 → ALU运算 → 存结果 |
| **转移指令** | 修改PC值 |
| **空操作指令** | 无操作 |
### 8.2.5 指令周期的时序
```mermaid
graph TB
subgraph "指令周期时序"
T0[时钟周期T0] --> T1[时钟周期T1]
T1 --> T2[时钟周期T2]
T2 --> T3[时钟周期T3]
end
subgraph "取指周期"
T0 --> F1[PC → MAR]
F1 --> F2[读主存]
F2 --> F3[MDR → IR]
F3 --> F4[PC+1]
end
subgraph "执行周期"
T0 --> E1[分析指令]
E1 --> E2[取操作数]
E2 --> E3[执行操作]
E3 --> E4[存结果]
end
```
### 8.2.6 指令流水
> [!info] 概念
> 将指令执行过程分解为多个阶段，各阶段并行执行。
**流水线阶段**：
```mermaid
graph LR
subgraph "指令流水线"
IF[取指IF] --> ID[译码ID] --> EX[执行EX] --> MEM[访存MEM] --> WB[写回WB]
end
```
**流水线时序**：
```mermaid
gantt
title 指令流水线时序
dateFormat X
axisFormat %s
section 指令1
取指IF : 0, 1
译码ID : 1, 2
执行EX : 2, 3
访存MEM : 3, 4
写回WB : 4, 5
section 指令2
取指IF : 1, 2
译码ID : 2, 3
执行EX : 3, 4
访存MEM : 4, 5
写回WB : 5, 6
section 指令3
取指IF : 2, 3
译码ID : 3, 4
执行EX : 4, 5
访存MEM : 5, 6
写回WB : 6, 7
```
**加速比**：
$$S = \frac{非流水线时间}{流水线时间} = \frac{n \times k}{k + (n-1)}$$
- n：指令数
- k：流水线级数
**流水线冲突**：
| 冲突类型 | 原因 | 解决方法 |
|----------|------|----------|
| **结构冲突** | 硬件资源冲突 | 资源复制 |
| **数据冲突** | 数据依赖 | 数据前递、流水线暂停 |
| **控制冲突** | 分支指令 | 分支预测、延迟分支 |
---
## 8.3 中断系统
### 8.3.1 中断的作用
> [!info] 中断定义
> 中断是指CPU暂停现行程序，转去处理中断请求，处理完毕后返回原程序继续执行。
**主要作用**：
1. **实现CPU与IO设备并行工作**
2. **处理机器故障**
3. **实现人机交互**
4. **实现多道程序**
### 8.3.2 中断系统组成
```mermaid
graph TB
subgraph "中断系统"
subgraph "中断源"
IO[I/O设备]
TIMER[定时器]
FAULT[故障]
SOFT[软件中断]
end
subgraph "中断判优"
PRIO[优先级电路]
end
subgraph "中断响应"
MASK[中断屏蔽]
INTR[中断请求]
INTA[中断响应]
end
subgraph "中断处理"
SAVE[保存现场]
SERVICE[中断服务]
RESTORE[恢复现场]
end
end
IO --> INTR
TIMER --> INTR
FAULT --> INTR
SOFT --> INTR
INTR --> PRIO
PRIO --> MASK
MASK --> INTA
INTA --> SAVE
SAVE --> SERVICE
SERVICE --> RESTORE
```
### 8.3.3 中断处理过程
```mermaid
graph TB
START[中断请求] --> CHECK{允许中断?}
CHECK -->|否| WAIT[等待]
CHECK -->|是| SAVE1[保存断点]
SAVE1 --> SAVE2[保存现场]
SAVE2 --> EI[开中断]
EI --> SERVICE[执行中断服务程序]
SERVICE --> DI[关中断]
DI --> RESTORE1[恢复现场]
RESTORE1 --> RESTORE2[恢复断点]
RESTORE2 --> RET[中断返回]
RET --> END[继续执行]
```
### 8.3.4 中断判优
**优先级原则**：
1. 硬件故障 > 软件中断
2. 高速设备 > 低速设备
3. 输入 > 输出
4. 实时设备 > 普通设备
**判优方法**：
| 方法 | 原理 | 特点 |
|------|------|------|
| 硬件判优 | 优先级电路 | 速度快 |
| 软件判优 | 程序查询 | 灵活，速度慢 |
---
## 📝 本章小结
### 核心概念
1. **CPU功能**：指令控制、操作控制、时间控制、数据加工、中断处理
2. **CPU寄存器**：PC、IR、MAR、MDR、通用寄存器、PSW
3. **指令周期**：取指周期 + 执行周期
4. **指令流水**：提高并行度，加速指令执行
5. **中断系统**：实现CPU与IO并行，处理异常
### 关键公式
- **流水线加速比**：$S = \frac{n \times k}{k + (n-1)}$
### 重点图示
> [!summary] 必须掌握的内容
> 1. CPU内部结构框图
> 2. 指令周期流程图
> 3. 指令流水线时序图
> 4. 中断处理流程图
---
## 🧪 自测练习
### 概念题
1. 说明CPU的基本功能。
2. 比较CPU中各类寄存器的作用。
3. 解释指令流水线的原理和冲突。
### 分析题
1. 画出取指周期的时序图。
2. 设计一个简单的中断处理流程。
---
## 🔗 相关链接
- [[07_指令系统]] - 上一章
- [[09_控制单元功能]] - 下一章
- [[10_控制单元设计]] - 控制单元设计
- [[05_输入输出系统]] - 中断系统
---
*本章难度：⭐⭐⭐⭐⭐ 困难*
*重要程度：⭐⭐⭐⭐⭐ 核心重点*

349
计算机组成原理/学习笔记/08_CPU结构与功能_补充版.md Normal file
View File

@@ -0,0 +1,349 @@
# 第8章 CPU的结构和功能
> 📖 本章介绍CPU的功能、内部结构和指令执行过程。
> 🎯 重点理解CPU组成和指令周期
---
## 📋 本章目录
- [[#8.1 CPU的结构]]
- [[#8.2 指令周期]]
- [[#8.3 指令流水]]
- [[#8.4 中断系统]]
- [[#本章小结]]
- [[#例题与解析]]
---
## 8.1 CPU的结构
### 8.1.1 CPU的功能
> [!info] 核心功能
> CPU负责协调并控制计算机各部件执行程序的指令序列。
**基本功能**：
| 功能 | 说明 |
|------|------|
| **指令控制** | 控制程序的顺序执行 |
| **操作控制** | 产生完成每条指令所需的控制命令 |
| **时间控制** | 对各种操作加以时间上的控制 |
| **数据加工** | 对数据进行算术运算和逻辑运算 |
| **中断处理** | 处理异常情况和特殊请求 |
CPU就像公司的大脑：指令控制按顺序执行程序，像总经理按顺序安排工作；操作控制产生控制信号，像总经理发出工作指令；时间控制控制操作时序，像总经理控制工作进度；数据加工进行各种运算，像员工处理数据；中断处理处理紧急事件，像总经理处理紧急情况。
### 8.1.2 CPU结构框图
```mermaid
graph TB
subgraph "CPU内部结构"
subgraph "运算器"
ALU[ALU<br/>算术逻辑单元]
ACC[ACC<br/>累加寄存器]
PSW[PSW<br/>程序状态字]
REG[通用寄存器组]
end
subgraph "控制器"
CU[CU<br/>控制单元]
PC[PC<br/>程序计数器]
IR[IR<br/>指令寄存器]
MAR[MAR<br/>存储器地址寄存器]
MDR[MDR<br/>存储器数据寄存器]
end
end
ALU <--> |"数据"| REG
ALU <--> |"数据"| ACC
CU --> |"控制信号"| ALU
CU --> |"控制信号"| REG
PC --> |"地址"| MAR
IR --> |"指令"| CU
MAR <--> |"地址"| MEM[主存]
MDR <--> |"数据"| MEM
style ALU fill:#ff9999
style CU fill:#99ccff
style PC fill:#99ff99
style IR fill:#ffcc99
```
CPU结构就像公司的组织架构：运算器中，ALU（算术逻辑单元）是生产车间负责加工产品，ACC（累加寄存器）是操作台临时存放加工中的产品，PSW（程序状态字）是状态指示灯显示当前工作状态，通用寄存器组是工具箱存放常用工具。控制器中，CU（控制单元）是总经理指挥整个公司运转，PC（程序计数器）是任务清单记录下一个要执行的任务，IR（指令寄存器）是当前任务单记录正在执行的任务，MAR（存储器地址寄存器）是仓库地址簿记录要访问的仓库位置，MDR（存储器数据寄存器）是传送带传送仓库和车间之间的物品。
当你执行一条加法指令时：PC记录下一条指令的地址，IR存放当前加法指令，CU译码并发出控制信号，ALU执行加法运算，ACC存放运算结果，PSW记录运算状态。
### 8.1.3 CPU的寄存器
#### 用户可见寄存器
| 寄存器类型 | 功能 | 示例 |
|------------|------|------|
| **通用寄存器** | 可编程使用，存放操作数 | AX, BX, CX, DX |
| **数据寄存器** | 存放操作数 | 数据寄存器 |
| **地址寄存器** | 存放地址 | 基址寄存器、变址寄存器 |
| **条件码寄存器** | 存放运算结果状态 | Z（零）、C（进位）、S（符号）、O（溢出） |
通用寄存器像员工可以使用的工具，可编程使用存放各种数据；数据寄存器专门存放数据；地址寄存器专门存放地址；条件码寄存器记录运算结果的状态。
#### 控制和状态寄存器
| 寄存器 | 功能 | 可见性 |
|--------|------|--------|
| **PC** | 程序计数器，存放现行指令地址 | 用户可见 |
| **IR** | 指令寄存器，存放当前指令 | 用户不可见 |
| **MAR** | 存储器地址寄存器 | 用户不可见 |
| **MDR** | 存储器数据寄存器 | 用户不可见 |
| **PSW** | 程序状态字寄存器 | 部分可见 |
PC（程序计数器）记录下一个要执行的任务，执行完一个任务后自动指向下一个任务，遇到跳转指令时指向跳转目标。IR（指令寄存器）记录正在执行的任务，包含操作码（要做什么）和地址码（操作数在哪里），操作码送给CU译码。MAR（存储器地址寄存器）记录要访问的仓库位置，把地址送到仓库。MDR（存储器数据寄存器）传送仓库和车间之间的物品。PSW（程序状态字寄存器）显示当前工作状态，包括条件码、中断屏蔽位等。
---
## 8.2 指令周期
### 8.2.1 指令周期的基本概念
> [!info] 定义
> 指令周期是指从取指令到执行完该指令所需的全部时间。
**指令周期的组成**：
- **取指周期**：取指令的时间
- **执行周期**：执行指令的时间
指令周期就像完成一个任务的时间：取指周期是从仓库取任务单的时间，执行周期是执行任务的时间。简单指令取指周期+执行周期，复杂指令取指周期+多个执行周期。
### 8.2.2 指令周期的时序
```mermaid
graph TB
A[取指周期] --> B[执行周期]
B --> C[取指周期]
C --> D[执行周期]
D --> E[...]
```
**时序信号**：
- **时钟周期**：CPU的最小时间单位
- **机器周期**：完成一个基本操作的时间
- **指令周期**：完成一条指令的时间
时钟周期像CPU的最小工作时间单位，1GHz CPU的时钟周期是1ns；机器周期完成一个基本操作的时间，通常包含几个时钟周期；指令周期完成一条指令的时间，根据指令类型不同而不同。
### 8.2.3 指令执行过程
**取指周期**：
1. PC → MAR → 地址总线
2. CU发出读命令
3. 存储器 → 数据总线 → MDR
4. MDR → IR
5. PC + 1 → PC
**执行周期**：
1. IR的操作码 → CU译码
2. CU发出控制信号
3. 执行指令操作
取指周期像从仓库取任务单：把任务单地址送到仓库地址簿，告诉仓库要取任务单，仓库把任务单送到传送带，任务单送到当前任务单，任务清单指向下一个任务。执行周期像执行任务：总经理看任务单决定要做什么，总经理发出工作指令，员工执行任务。
当你执行一条加法指令时：取指周期从内存取加法指令到CPU，执行周期执行加法运算。
---
## 8.3 指令流水
### 8.3.1 流水线的基本概念
> [!info] 定义
> 流水线是指将指令执行过程分成多个阶段，多个指令可以同时在不同阶段执行。
**流水线的阶段**：
- **取指（IF）**：取指令
- **译码（ID）**：译码指令
- **执行（EX）**：执行指令
- **访存（MEM）**：访问存储器
- **写回（WB）**：写回结果
流水线就像工厂的生产线：取指从仓库取原材料，译码看图纸决定要做什么，执行加工产品，访存从仓库取需要的材料，写回把成品放到仓库。多个指令可以同时在不同阶段执行，提高吞吐率和效率。
### 8.3.2 流水线的性能
**吞吐率**：
$$TP = \frac{n}{k + (n-1)}$$
**加速比**：
$$S = \frac{nk}{k + (n-1)}$$
**效率**：
$$E = \frac{S}{k} = \frac{n}{k + (n-1)}$$
流水线性能像工厂的生产效率：吞吐率是单位时间完成的任务数，加速比是流水线比非流水线快多少倍，效率是流水线的利用率。
假设流水线有4个阶段，执行100条指令：吞吐率100/(4+99)=0.97条/周期，加速比100×4/(4+99)=3.88，效率3.88/4=97%。
### 8.3.3 流水线冲突
**结构冲突**：硬件资源不足，两个指令同时访问同一个存储器，增加硬件资源解决。
**数据冲突**：指令之间有数据依赖，后面的指令需要前面指令的结果，数据旁路或流水线暂停解决。
**控制冲突**：分支指令改变程序流，跳转指令导致流水线需要重新取指，分支预测或延迟分支解决。
结构冲突像两个工人都要用同一个工具，多买几个工具解决；数据冲突像上一个产品还没做完下一个产品需要它的零件，等做完或先做其他产品解决；控制冲突像突然改变生产计划，提前预测或等确定后再生产解决。
---
## 8.4 中断系统
### 8.4.1 中断系统的基本功能
**主要功能**：
1. **中断请求**：接收中断请求信号
2. **中断判优**：决定哪个中断先处理
3. **中断响应**：响应中断请求
4. **中断处理**：执行中断服务程序
5. **中断返回**：返回原程序
中断系统像公司的紧急事件处理系统：中断请求接收紧急事件报告，中断判优决定先处理哪个紧急事件，中断响应决定处理紧急事件，中断处理执行紧急事件处理程序，中断返回返回原工作。
### 8.4.2 中断系统的实现
**硬件实现**：
- **中断请求触发器**：保存中断请求信号
- **中断屏蔽触发器**：控制中断是否被屏蔽
- **中断判优电路**：决定中断优先级
- **中断向量表**：存放中断服务程序入口地址
**软件实现**：
- **中断服务程序**：处理中断的程序
- **中断处理流程**：中断处理的步骤
硬件实现像紧急事件处理流程：中断请求触发器是紧急事件报告箱，中断屏蔽触发器是请勿打扰标志，中断判优电路是紧急事件分类器，中断向量表是紧急事件处理手册。
---
## 📝 本章小结
### 核心概念
1. **CPU功能**：指令控制、操作控制、时间控制、数据加工、中断处理
2. **CPU结构**：运算器、控制器、寄存器
3. **指令周期**：取指周期、执行周期
4. **指令流水**：提高CPU效率的重要技术
5. **中断系统**：处理紧急事件的机制
### 关键术语
| 术语 | 英文 | 含义 |
|------|------|------|
| CPU | Central Processing Unit | 中央处理器 |
| ALU | Arithmetic Logic Unit | 算术逻辑单元 |
| CU | Control Unit | 控制单元 |
| PC | Program Counter | 程序计数器 |
| IR | Instruction Register | 指令寄存器 |
| 流水线 | Pipeline | 指令流水 |
| 中断 | Interrupt | 紧急事件处理 |
### 重点图示
> [!summary] 必须掌握的图
> 1. CPU内部结构图
> 2. 指令周期时序图
> 3. 流水线示意图
> 4. 中断处理流程图
---
## 🧪 例题与解析
### 例题1：CPU功能分析
**题目**：简述CPU的五大功能。
**答案**：
CPU的五大功能：指令控制控制程序的顺序执行，像总经理按顺序安排工作；操作控制产生完成每条指令所需的控制信号，像总经理发出工作指令；时间控制对各种操作加以时间上的控制，像总经理控制工作进度；数据加工对数据进行算术运算和逻辑运算，像员工处理数据；中断处理处理异常情况和特殊请求，像总经理处理紧急情况。
### 例题2：指令周期计算
**题目**：某CPU主频为1GHz，取指周期为4个时钟周期，执行周期为6个时钟周期，求执行100条指令所需时间。
**答案**：
主频1GHz=10⁹Hz，时钟周期1/10⁹=1ns。
取指周期4个时钟周期=4ns，执行周期6个时钟周期=6ns。
单条指令时间=4+6=10ns。
100条指令时间=100×10ns=1000ns=1μs。
### 例题3：流水线性能计算
**题目**：某CPU有4级流水线，执行100条指令，求吞吐率、加速比和效率。
**答案**：
流水线阶段数k=4，指令数n=100。
吞吐率TP=100/(4+99)=0.97条/周期。
加速比S=100×4/(4+99)=3.88。
效率E=3.88/4=97%。
### 例题4：流水线冲突分析
**题目**：分析以下指令序列中的数据冲突：
```
ADD R1, R2, R3 ; R1 = R2 + R3
SUB R4, R1, R5 ; R4 = R1 - R5
```
**答案**：
ADD指令产生R1的值，SUB指令需要R1的值。如果ADD指令还没执行完SUB指令就需要R1的值，就会发生数据冲突。
解决方案：数据旁路（ADD指令执行完后直接把结果传给SUB指令）或流水线暂停（等ADD指令执行完后再执行SUB指令）。
### 例题5：中断系统设计
**题目**：设计一个简单的中断系统，支持4个中断源。
**答案**：
中断请求：4个中断请求触发器（IR0-IR3）保存中断请求信号。
中断屏蔽：4个中断屏蔽触发器（IM0-IM3）控制中断是否被屏蔽。
中断判优：优先级编码器，IR0>IR1>IR2>IR3。
中断响应：中断响应信号（INTA），CPU响应中断请求。
中断向量表：4个中断向量，存放中断服务程序入口地址。
---
## ⚡ 知识点速记卡
> 考前快速过一遍，30秒回忆整章核心
**CPU五大功能**：指令控制（顺序执行）、操作控制（发控制信号）、时间控制（时序）、数据加工（ALU运算）、中断处理。
**CPU内部关键寄存器**：PC（下条指令地址）、IR（当前指令）、MAR（访存地址）、MDR（访存数据）、PSW（程序状态）、ACC（累加器）、通用寄存器组。
**指令周期四阶段**：取指周期（所有指令都有）→ 间址周期（间接寻址才有）→ 执行周期（都有）→ 中断周期（有中断才有）。
**流水线五阶段**：IF（取指）→ ID（译码）→ EX（执行）→ MEM（访存）→ WB（写回）。
**流水线公式**：吞吐率 TP = n/(k+n-1)，加速比 S = nk/(k+n-1)。n=100条、k=4级 → TP≈0.97，S≈3.88。
**流水线三种冲突**：结构冲突（争硬件，加资源）、数据冲突（数据依赖，旁路或暂停）、控制冲突（分支跳转，预测或延迟）。
**中断系统**：中断请求触发器保存请求，中断屏蔽触发器控制屏蔽，中断判优电路决定优先级，中断向量表存入口地址。
---
## 🔗 相关链接
- [[00_计算机组成原理学习指南]] - 返回主目录
- [[07_指令系统]] - 上一章
- [[09_控制单元功能]] - 下一章
- [[10_控制单元设计]] - 控制单元设计
---
*本章难度：⭐⭐⭐⭐⭐ 困难*
*重要程度：⭐⭐⭐⭐⭐ 重点*

332
计算机组成原理/学习笔记/09_控制单元功能.md Normal file
View File

@@ -0,0 +1,332 @@
# 第9章 控制单元的功能
> 📖 本章分析控制单元为完成不同指令所发出的各种微操作命令。
> 🎯 重点理解微操作命令和指令执行过程
---
## 📋 本章目录
- [[#9.1 微操作命令的分析]]
- [[#9.2 控制单元的功能]]
- [[#本章小结]]
---
## 9.1 微操作命令的分析
### 9.1.1 微操作命令的概念
> [!info] 定义
> 微操作命令是控制单元发出的最基本控制信号，控制计算机各部件完成相应操作。
**特点**：
- 是最基本的操作，不可再分
- 由控制单元发出
- 控制数据通路和功能部件
### 9.1.2 指令周期的四个阶段
```mermaid
graph LR
A[指令周期] --> B[取指周期]
A --> C[间址周期]
A --> D[执行周期]
A --> E[中断周期]
```
### 9.1.3 取指周期的微操作
**操作序列**：
| 步骤 | 微操作 | 说明 |
|------|--------|------|
| 1 | PC → MAR | 现行指令地址送MAR |
| 2 | 1 → R | 向主存发读命令 |
| 3 | M(MAR) → MDR | 指令从主存读至MDR |
| 4 | MDR → IR | 指令送指令寄存器 |
| 5 | OP(IR) → CU | 操作码送CU译码 |
| 6 | (PC) + 1 → PC | 程序计数器加1 |
```mermaid
sequenceDiagram
participant PC
participant MAR
participant MEM as 主存
participant MDR
participant IR
participant CU
PC->>MAR: PC → MAR
Note over MAR: 1 → R（发读命令）
MEM->>MDR: M(MAR) → MDR
MDR->>IR: MDR → IR
IR->>CU: OP(IR) → CU
Note over PC: (PC) + 1 → PC
```
### 9.1.4 间址周期的微操作
**操作序列**：
| 步骤 | 微操作 | 说明 |
|------|--------|------|
| 1 | Ad(IR) → MAR | 形式地址送MAR |
| 2 | 1 → R | 向主存发读命令 |
| 3 | M(MAR) → MDR | 有效地址从主存读至MDR |
| 4 | MDR → Ad(IR) | 有效地址送IR地址字段 |
```mermaid
sequenceDiagram
participant IR
participant MAR
participant MEM as 主存
participant MDR
IR->>MAR: Ad(IR) → MAR
Note over MAR: 1 → R（发读命令）
MEM->>MDR: M(MAR) → MDR
MDR->>IR: MDR → Ad(IR)
```
### 9.1.5 执行周期的微操作
#### 1. 非访存指令
| 指令 | 微操作 | 说明 |
|------|--------|------|
| CLA | 0 → ACC | 清除累加器 |
| COM | $\overline{ACC}$ → ACC | 累加器取反 |
| SHR | L(ACC) → R(ACC), ACC₀ → ACC₀ | 算术右移 |
| CSL | R(ACC) → L(ACC), ACC₀ → ACCₙ | 循环左移 |
| STP | 0 → G | 停机 |
#### 2. 访存指令
##### 加法指令 ADD X
| 步骤 | 微操作 | 说明 |
|------|--------|------|
| 1 | Ad(IR) → MAR | 地址送MAR |
| 2 | 1 → R | 发读命令 |
| 3 | M(MAR) → MDR | 操作数读至MDR |
| 4 | (ACC) + (MDR) → ACC | 加法运算 |
##### 存数指令 STA X
| 步骤 | 微操作 | 说明 |
|------|--------|------|
| 1 | Ad(IR) → MAR | 地址送MAR |
| 2 | 1 → W | 发写命令 |
| 3 | ACC → MDR | 数据送MDR |
| 4 | MDR → M(MAR) | 数据写入主存 |
##### 取数指令 LDA X
| 步骤 | 微操作 | 说明 |
|------|--------|------|
| 1 | Ad(IR) → MAR | 地址送MAR |
| 2 | 1 → R | 发读命令 |
| 3 | M(MAR) → MDR | 数据读至MDR |
| 4 | MDR → ACC | 数据送累加器 |
#### 3. 转移类指令
| 指令 | 微操作 | 说明 |
|------|--------|------|
| JMP X | Ad(IR) → PC | 无条件转移 |
| BAN X | A₀·Ad(IR) + $\overline{A₀}$·(PC) → PC | 条件转移（负则转） |
### 9.1.6 中断周期的微操作
**操作序列**：
| 步骤 | 微操作 | 说明 |
|------|--------|------|
| 1 | 0 → MAR | 特定地址送MAR |
| 2 | 1 → W | 发写命令 |
| 3 | PC → MDR | 断点送MDR |
| 4 | MDR → M(MAR) | 断点存入主存 |
| 5 | 向量地址 → PC | 中断服务程序入口送PC |
| 6 | 0 → EINT | 关中断 |
```mermaid
sequenceDiagram
participant PC
participant MAR
participant MDR
participant MEM as 主存
Note over MAR: 0 → MAR
Note over MAR: 1 → W（发写命令）
PC->>MDR: PC → MDR
MDR->>MEM: MDR → M(MAR)
Note over PC: 向量地址 → PC
Note over PC: 0 → EINT（关中断）
```
---
## 9.2 控制单元的功能
### 9.2.1 控制单元的外特性
```mermaid
graph TB
subgraph "控制单元CU"
INPUT[输入] --> CU[控制单元]
CU --> OUTPUT[输出]
end
subgraph "输入信号"
CLK[时钟]
INST[指令寄存器]
FLAG[标志]
INT[中断请求]
BUS[总线信号]
end
subgraph "输出信号"
CTRL[控制信号]
ADDR[地址信号]
DATA[数据信号]
end
CLK --> INPUT
INST --> INPUT
FLAG --> INPUT
INT --> INPUT
BUS --> INPUT
OUTPUT --> CTRL
OUTPUT --> ADDR
OUTPUT --> DATA
```
### 9.2.2 控制信号
**控制信号分类**：
| 类型 | 说明 | 示例 |
|------|------|------|
| **操作控制信号** | 控制数据通路操作 | ALU操作、寄存器读写 |
| **时序控制信号** | 控制操作时序 | 时钟、节拍 |
| **总线控制信号** | 控制总线操作 | 总线请求、总线允许 |
### 9.2.3 控制信号举例
#### 取指周期的控制信号
| 时钟 | 控制信号 | 功能 |
|------|----------|------|
| T₀ | PCout, MARin | PC → MAR |
| T₁ | MemR, MARout | 读主存 |
| T₂ | MDRinE | M(MAR) → MDR |
| T₃ | MDRout, IRin | MDR → IR |
| T₄ | PC+1 | PC加1 |
#### 执行周期的控制信号（加法指令）
| 时钟 | 控制信号 | 功能 |
|------|----------|------|
| T₀ | IRout, MARin | Ad(IR) → MAR |
| T₁ | MemR, MARout | 读主存 |
| T₂ | MDRinE | M(MAR) → MDR |
| T₃ | MDRout, Yin | MDR → Y |
| T₄ | ADD, Zin | ACC + Y → Z |
| T₅ | Zout, ACCin | Z → ACC |
### 9.2.4 多级时序系统
```mermaid
graph TB
subgraph "多级时序系统"
MACHINE[机器周期] --> CLOCK[时钟周期]
CLOCK --> MICRO[微操作]
end
subgraph "时序关系"
T[指令周期] --> M1[机器周期1]
T --> M2[机器周期2]
T --> M3[机器周期3]
M1 --> C1[时钟周期T0]
M1 --> C2[时钟周期T1]
M1 --> C3[时钟周期T2]
end
```
**时序关系**：
- **指令周期**：取出并执行一条指令的时间
- **机器周期**：完成一个基本操作的时间
- **时钟周期**：最基本的时序单位
### 9.2.5 控制方式
#### 1. 同步控制方式
> [!info] 特点
> 所有操作由统一时钟控制，时序固定。
**优点**：设计简单，可靠性高
**缺点**：效率低，不灵活
#### 2. 异步控制方式
> [!info] 特点
> 操作按需进行，采用应答方式。
**优点**：效率高，灵活
**缺点**：设计复杂
#### 3. 联合控制方式
> [!info] 特点
> 同步和异步结合，大部分操作同步，特殊操作异步。
**应用**：现代计算机常用
---
## 📝 本章小结
### 核心概念
1. **微操作命令**：最基本的控制信号
2. **指令周期**：取指周期、间址周期、执行周期、中断周期
3. **控制信号**：控制数据通路和功能部件
4. **时序系统**：机器周期、时钟周期
### 重点图示
> [!summary] 必须掌握的内容
> 1. 指令周期四个阶段的微操作序列
> 2. 控制单元的外特性
> 3. 多级时序系统
> 4. 各类指令的控制信号
---
## 🧪 自测练习
### 概念题
1. 说明微操作命令的概念和特点。
2. 比较指令周期四个阶段的微操作。
3. 解释控制信号的作用和分类。
### 分析题
1. 写出加法指令的微操作序列。
2. 设计取指周期的控制信号。
---
## 🔗 相关链接
- [[08_CPU结构与功能]] - 上一章
- [[10_控制单元设计]] - 下一章
- [[07_指令系统]] - 指令格式
---
*本章难度：⭐⭐⭐⭐ 中等偏难*
*重要程度：⭐⭐⭐⭐ 重点*

312
计算机组成原理/学习笔记/09_控制单元功能_补充版.md Normal file
View File

@@ -0,0 +1,312 @@
# 第9章 控制单元功能（详细补充版）
> 📖 本章分析控制单元为完成不同指令所发出的各种微操作命令。
> 🎯 重点理解微操作命令和指令执行过程
---
## 📋 本章目录
- [[#9.1 微操作命令的分析]]
- [[#9.2 控制单元的功能]]
- [[#本章小结]]
- [[#例题与解析]]
---
## 9.1 微操作命令的分析
### 9.1.1 微操作命令的概念
> [!info] 定义
> 微操作命令是控制单元发出的最基本控制信号，控制计算机各部件完成相应操作。
要理解微操作命令，可以把它想象成工厂里最细粒度的工作指令——"拿起零件"、"转动螺丝"这样的最小动作，不能再拆分了。整个计算机的工作，就是由控制单元不断发出这些最基础的信号，指挥数据通路和各个功能部件协同配合。
比如 `PC → MAR` 就是一条微操作命令，意思是把程序计数器的值送到地址寄存器；`1 → R` 是向主存发出读命令。每一条都很简单，但组合起来就能完成复杂的指令执行。
### 9.1.2 指令周期的四个阶段
```mermaid
graph LR
A[指令周期] --> B[取指周期]
A --> C[间址周期]
A --> D[执行周期]
A --> E[中断周期]
```
一条指令从开始执行到完成，要经历四个阶段，就像完成一个任务需要"拿任务单→确认地址→干活→处理突发情况"这几个步骤。
**取指周期**是每条指令都有的，负责从内存把指令取到CPU里。**间址周期**只有间接寻址的指令才需要——就像你拿到的纸条上写的是"去3号柜找"，但3号柜里放的才是真正的东西的地址，你需要先去3号柜拿到真实地址。**执行周期**是真正干活的阶段，不同指令做的事情不同，花的时间也不同。**中断周期**不是每条指令都有，只有发生了中断（比如键盘按键、打印机完成）才会进入这个阶段去处理紧急事件。
### 9.1.3 取指周期的微操作
取指周期是所有指令共有的阶段，它的微操作序列是固定的：
| 步骤 | 微操作 | 说明 |
|------|--------|------|
| 1 | PC → MAR | 现行指令地址送MAR |
| 2 | 1 → R | 向主存发读命令 |
| 3 | M(MAR) → MDR | 指令从主存读至MDR |
| 4 | MDR → IR | 指令送指令寄存器 |
| 5 | OP(IR) → CU | 操作码送CU译码 |
| 6 | (PC) + 1 → PC | 程序计数器加1 |
```mermaid
sequenceDiagram
participant PC
participant MAR
participant MEM as 主存
participant MDR
participant IR
participant CU
PC->>MAR: PC → MAR
Note over MAR: 1 → R（发读命令）
MEM->>MDR: M(MAR) → MDR
MDR->>IR: MDR → IR
IR->>CU: OP(IR) → CU
Note over PC: (PC) + 1 → PC
```
这个过程很直白：先把PC里的地址送到MAR，告诉主存"我要读这个地址的东西"，主存把指令送到MDR，再从MDR搬到IR，同时把操作码送给CU去译码，最后PC加1指向下一条指令。整个流程就像从货架上取货——先告诉仓库你要哪个货架的东西（PC→MAR），仓库把东西放到传送带上（M(MAR)→MDR），你从传送带上拿过来（MDR→IR），然后看看是什么东西（OP(IR)→CU），同时记一下下一个要取的位置（(PC)+1→PC）。
### 9.1.4 间址周期的微操作
间址周期只在间接寻址时出现，目的是把形式地址转换成有效地址：
| 步骤 | 微操作 | 说明 |
|------|--------|------|
| 1 | Ad(IR) → MAR | 形式地址送MAR |
| 2 | 1 → R | 向主存发读命令 |
| 3 | M(MAR) → MDR | 有效地址从主存读至MDR |
| 4 | MDR → Ad(IR) | 有效地址送IR地址字段 |
```mermaid
sequenceDiagram
participant IR
participant MAR
participant MEM as 主存
participant MDR
IR->>MAR: Ad(IR) → MAR
Note over MAR: 1 → R（发读命令）
MEM->>MDR: M(MAR) → MDR
MDR->>IR: MDR → Ad(IR)
```
间接寻址就像你拿到一张纸条写着"去3号柜找"，3号柜里放的才是真正的目标地址。间址周期做的事情就是：先把纸条上的地址（形式地址）送去查，然后从那个位置拿到真正的地址（有效地址），再把有效地址写回指令的地址字段，这样后面执行周期就知道该去哪取数据了。
### 9.1.5 执行周期的微操作
执行周期的微操作取决于指令类型，不同指令差异很大。
**非访存指令**不需要访问内存，操作直接在CPU内部完成：
| 指令 | 微操作 | 说明 |
|------|--------|------|
| CLA | 0 → ACC | 清除累加器 |
| COM | $\overline{ACC}$ → ACC | 累加器取反 |
| SHR | L(ACC) → R(ACC), ACC₀ → ACC₀ | 算术右移 |
| CSL | L(ACC) → R(ACC), ACC₀ → ACCₙ | 循环左移 |
| STP | 0 → G | 停机指令 |
这些指令都很简单——CLA就是把累加器清零，COM是把每一位取反（0变1、1变0），SHR是算术右移一位（相当于除以2），CSL是循环左移，STP是停机。它们不需要去内存取数据，所以执行周期很短。
**访存指令**需要访问内存，执行周期包含访存操作：
| 指令 | 微操作 | 说明 |
|------|--------|------|
| ADD X | Ad(IR) → MAR, 1 → R, M(MAR) → MDR, (ACC) + (MDR) → ACC | 加法指令 |
| STA X | Ad(IR) → MAR, 1 → W, ACC → MDR, MDR → M(MAR) | 存数指令 |
| LDA X | Ad(IR) → MAR, 1 → R, M(MAR) → MDR, MDR → ACC | 取数指令 |
ADD X 是把内存地址X处的数取出来加到累加器；STA X 是把累加器的值存到内存地址X；LDA X 是把内存地址X处的数取到累加器。它们都需要先送地址、再读写内存、最后在CPU内部完成数据操作。
**转移指令**改变程序的执行顺序：
| 指令 | 微操作 | 说明 |
|------|--------|------|
| JMP X | Ad(IR) → PC | 无条件转移 |
| BAN X | A₀ · Ad(IR) + $\overline{A₀}$ · (PC) → PC | 条件转移（负则转） |
JMP X 就是无条件跳转到地址X，直接把X送到PC。BAN X 是条件转移——如果累加器最高位（符号位）为1（表示负数），就跳转到X；否则继续执行下一条指令。
---
## 9.2 控制单元的功能
### 9.2.1 控制单元的外特性
控制单元是整个CPU的指挥中心，它接收各种输入信号，然后发出控制信号指挥各部件工作。
**输入信号**包括四类：时钟信号让CU按节拍工作，就像乐队指挥跟着节拍器；指令寄存器送来操作码，告诉CU当前要执行什么指令；标志位（条件码）提供运算结果的状态信息，帮助CU决定是否跳转；外来信号包括中断请求、总线请求等外部事件。
**输出信号**分两类：CPU内部控制信号控制ALU、寄存器等内部部件的操作；到控制总线的信号则控制主存和I/O设备的读写。
### 9.2.2 控制信号的时序
控制信号不是随意发出的，必须按照严格的时序来。时钟周期是CPU的最小时间单位（比如1GHz CPU的时钟周期是1ns），机器周期完成一个基本操作（通常包含几个时钟周期），指令周期完成一条指令（包含一个或几个机器周期）。
在取指周期，每个时钟周期发出一组控制信号，按固定顺序完成取指操作。在执行周期，根据指令类型的不同，CU会发出不同的控制信号组合——加法指令需要ALU做加法，存数指令需要向内存发写命令，转移指令需要修改PC的值。
### 9.2.3 控制信号的组成
控制信号按控制对象可以分为四类：ALU控制信号决定ALU做什么运算（加法、减法、逻辑与、逻辑或等）；寄存器控制信号控制寄存器的读写（哪些寄存器要读、哪些要写）；数据通路控制信号控制数据在CPU内部的传输方向（比如从ALU输出送到哪个寄存器）；总线控制信号控制总线的读写操作（读内存还是写内存）。
这些信号配合时序，在正确的时刻发出，就能指挥整个计算机协调工作。
---
## 📝 本章小结
### 核心概念
1. **微操作命令**：控制单元发出的最基本控制信号，不可再分
2. **指令周期**：取指周期→间址周期→执行周期→中断周期
3. **控制单元功能**：根据指令和时序，发出各种控制信号
### 关键术语
| 术语 | 英文 | 含义 |
|------|------|------|
| 微操作 | Micro-operation | 最基本的操作 |
| 控制单元 | Control Unit | 发出控制信号的部件 |
| 指令周期 | Instruction Cycle | 完成一条指令的时间 |
| 机器周期 | Machine Cycle | 完成一个基本操作的时间 |
### 重点图示
> [!summary] 必须掌握的图
> 1. 指令周期的四个阶段图
> 2. 取指周期的微操作序列图
> 3. 间址周期的微操作序列图
> 4. 各种指令的微操作序列图
---
## 🧪 例题与解析
### 例题1：取指周期分析
**题目**：写出取指周期的微操作序列。
**答案**：
取指周期的微操作序列：
1. **PC → MAR**：现行指令地址送MAR
2. **1 → R**：向主存发读命令
3. **M(MAR) → MDR**：指令从主存读至MDR
4. **MDR → IR**：指令送指令寄存器
5. **OP(IR) → CU**：操作码送CU译码
6. **(PC) + 1 → PC**：程序计数器加1
这六步是所有指令共有的，顺序不能变——必须先送地址才能读内存，必须先读到MDR才能送到IR，必须先送到IR才能译码。唯一可以和其他操作重叠的是最后一步PC加1，它和前面的译码操作可以并行。
### 例题2：间址周期分析
**题目**：写出间址周期的微操作序列。
**答案**：
间址周期的微操作序列：
1. **Ad(IR) → MAR**：形式地址送MAR
2. **1 → R**：向主存发读命令
3. **M(MAR) → MDR**：有效地址从主存读至MDR
4. **MDR → Ad(IR)**：有效地址送IR地址字段
间址周期的目的就是把形式地址变成有效地址。形式地址是指令里给出的地址，但它不是最终地址——那个位置存放的才是真正的有效地址。所以需要额外访问一次内存，把有效地址取出来，写回指令的地址字段，这样后续的执行周期就知道该去哪操作了。
### 例题3：加法指令分析
**题目**：写出加法指令 ADD X 的微操作序列。
**答案**：
加法指令 ADD X 的微操作序列：
1. **Ad(IR) → MAR**：形式地址送MAR
2. **1 → R**：向主存发读命令
3. **M(MAR) → MDR**：操作数从主存读至MDR
4. **(ACC) + (MDR) → ACC**：累加器内容与MDR内容相加，结果送ACC
前三步和取数指令一样，都是把内存地址X处的操作数取到MDR。第四步是关键——把累加器里原来的值和MDR里的值送到ALU做加法，结果写回累加器。如果X是间接寻址的，还需要在前面加一个间址周期来获取有效地址。
### 例题4：存数指令分析
**题目**：写出存数指令 STA X 的微操作序列。
**答案**：
存数指令 STA X 的微操作序列：
1. **Ad(IR) → MAR**：形式地址送MAR
2. **1 → W**：向主存发写命令
3. **ACC → MDR**：累加器内容送MDR
4. **MDR → M(MAR)**：MDR内容写入主存
STA X 和 LDA X 的区别在于方向相反：LDA 是从内存读到累加器，STA 是从累加器写到内存。注意第二步发的是写命令（1→W）而不是读命令（1→R），数据流方向也反过来——从ACC到MDR再到内存。
### 例题5：控制单元功能分析
**题目**：简述控制单元的功能和输入输出信号。
**答案**：
**控制单元的功能**：发出各种控制信号，控制计算机各部件在正确的时刻完成正确的操作。
**输入信号**：
- **时钟**：CU按节拍工作，每个时钟周期发出一组控制信号
- **指令寄存器**：操作码决定CU要发出什么控制信号
- **标志**：条件码决定是否需要跳转
- **外来信号**：中断请求、总线请求等外部事件
**输出信号**：
- **CPU内控制信号**：控制ALU、寄存器等内部部件
- **到控制总线的信号**：控制主存、I/O设备的读写
CU的工作可以这样理解：它看着指令（操作码），结合当前状态（标志），按照时钟节拍，在每个时刻发出正确的控制信号，指挥数据在各个部件之间流动，完成指令的功能。
---
## ⚡ 知识点速记卡
> 考前快速过一遍，30秒回忆整章核心
**微操作命令** = 控制单元发出的最基本控制信号，不可再分。如 PC→MAR、1→R。
**指令周期四阶段**：取指（所有指令）→ 间址（间接寻址才要）→ 执行（所有指令）→ 中断（有中断才要）。
**取指周期六步**（必须背）：PC→MAR → 1→R → M(MAR)→MDR → MDR→IR → OP(IR)→CU → (PC)+1→PC。
**间址周期四步**：Ad(IR)→MAR → 1→R → M(MAR)→MDR → MDR→Ad(IR)。目的：形式地址→有效地址。
**访存指令执行周期**：ADD X（读+加）、STA X（写）、LDA X（读+送ACC）。先送地址，再读写内存，最后CPU内部操作。
**非访存指令**：CLA清零、COM取反、SHR右移、CSL循环左移、STP停机，不访存所以快。
**控制单元输入**：时钟、操作码（IR）、标志、外来信号（中断/总线请求）。**输出**：CPU内部控制信号 + 控制总线信号。
---
## 🔗 相关链接
- [[00_计算机组成原理学习指南]] - 返回主目录
- [[08_CPU结构与功能]] - 上一章
- [[10_控制单元设计]] - 下一章
---
## 📚 参考资料
- 教材：《计算机组成原理》第3版 - 唐朔飞
- 复习资料：计算机组成原理知识点总结
- 习题：作业三、作业四
---
*本章难度：⭐⭐⭐⭐ 中等*
*重要程度：⭐⭐⭐⭐ 重要*
*补充版本：增加了通俗解释、实际例子和例题*

444
计算机组成原理/学习笔记/10_控制单元设计.md Normal file
View File

@@ -0,0 +1,444 @@
# 第10章 控制单元的设计
> 📖 本章介绍控制单元的两种设计方法：组合逻辑设计和微程序设计。
> 🎯 重点理解微程序设计方法
---
## 📋 本章目录
- [[#10.1 组合逻辑设计]]
- [[#10.2 微程序设计]]
- [[#本章小结]]
---
## 10.1 组合逻辑设计
### 10.1.1 组合逻辑控制单元框图
```mermaid
graph TB
subgraph "组合逻辑控制单元"
IR[IR<br/>指令寄存器] --> |"操作码"| DEC[操作码译码器]
CLK[时钟] --> |"时钟信号"| TG[节拍发生器]
DEC --> |"译码输出"| CU[控制单元]
TG --> |"节拍信号"| CU
FLAG[标志] --> CU
CU --> |"控制信号"| CTRL[控制信号输出]
end
```
**组成部分**：
- **操作码译码器**：将操作码译码，产生操作控制信号
- **节拍发生器**：产生时序信号，控制微操作顺序
- **控制单元**：根据译码结果和时序信号，产生控制信号
### 10.1.2 微操作的节拍安排
#### 安排原则
1. **顺序原则**：有些微操作次序不能改变
2. **并行原则**：不同控制对象的微操作可并行执行
3. **紧凑原则**：时间短的微操作可安排在同一节拍
#### 取指周期节拍安排
| 节拍 | 微操作 | 说明 |
|------|--------|------|
| T₀ | PC → MAR, 1 → R | 地址送MAR，发读命令 |
| T₁ | M(MAR) → MDR, (PC)+1 → PC | 读指令，PC加1 |
| T₂ | MDR → IR, OP(IR) → ID | 指令送IR，译码 |
```mermaid
sequenceDiagram
participant T0 as 节拍T0
participant T1 as 节拍T1
participant T2 as 节拍T2
Note over T0: PC → MAR, 1 → R
Note over T1: M(MAR) → MDR, (PC)+1 → PC
Note over T2: MDR → IR, OP(IR) → ID
```
#### 间址周期节拍安排
| 节拍 | 微操作 | 说明 |
|------|--------|------|
| T₀ | Ad(IR) → MAR, 1 → R | 形式地址送MAR |
| T₁ | M(MAR) → MDR | 读有效地址 |
| T₂ | MDR → Ad(IR) | 有效地址送IR |
#### 执行周期节拍安排
##### 非访存指令
| 指令 | T₀ | T₁ | T₂ |
|------|----|----|-----|
| CLA | 空 | 空 | 0 → ACC |
| COM | 空 | 空 | $\overline{ACC}$ → ACC |
| SHR | 空 | 空 | L(ACC) → R(ACC) |
| CSL | 空 | 空 | R(ACC) → L(ACC) |
| STP | 空 | 空 | 0 → G |
##### 访存指令
**加法指令 ADD X**：
| 节拍 | 微操作 |
|------|--------|
| T₀ | Ad(IR) → MAR, 1 → R |
| T₁ | M(MAR) → MDR |
| T₂ | (ACC) + (MDR) → ACC |
**存数指令 STA X**：
| 节拍 | 微操作 |
|------|--------|
| T₀ | Ad(IR) → MAR, 1 → W |
| T₁ | ACC → MDR |
| T₂ | MDR → M(MAR) |
**取数指令 LDA X**：
| 节拍 | 微操作 |
|------|--------|
| T₀ | Ad(IR) → MAR, 1 → R |
| T₁ | M(MAR) → MDR |
| T₂ | MDR → ACC |
##### 转移指令
**无条件转移 JMP X**：
| 节拍 | 微操作 |
|------|--------|
| T₀ | 空 |
| T₁ | 空 |
| T₂ | Ad(IR) → PC |
**条件转移 BAN X**：
| 节拍 | 微操作 |
|------|--------|
| T₀ | 空 |
| T₁ | 空 |
| T₂ | A₀·Ad(IR) + $\overline{A₀}$·(PC) → PC |
#### 中断周期节拍安排
| 节拍 | 微操作 | 说明 |
|------|--------|------|
| T₀ | 0 → MAR, 1 → W | 特定地址送MAR |
| T₁ | PC → MDR | 断点送MDR |
| T₂ | MDR → M(MAR), 向量地址 → PC | 存断点，置PC |
### 10.1.3 组合逻辑设计方法
#### 设计步骤
```mermaid
graph TB
A[列出微操作时间表] --> B[写出微操作逻辑表达式]
B --> C[画出逻辑电路图]
C --> D[优化电路]
```
#### 微操作逻辑表达式
**取指周期**：
- T₀：$PC \to MAR = T_0 \cdot FE$
- T₀：$1 \to R = T_0 \cdot FE$
- T₁：$M(MAR) \to MDR = T_1 \cdot FE$
- T₁：$(PC)+1 \to PC = T_1 \cdot FE$
- T₂：$MDR \to IR = T_2 \cdot FE$
- T₂：$OP(IR) \to ID = T_2 \cdot FE$
**加法指令 ADD X**：
- T₀：$Ad(IR) \to MAR = T_0 \cdot ADD \cdot EX$
- T₀：$1 \to R = T_0 \cdot ADD \cdot EX$
- T₁：$M(MAR) \to MDR = T_1 \cdot ADD \cdot EX$
- T₂：$(ACC)+(MDR) \to ACC = T_2 \cdot ADD \cdot EX$
#### 逻辑电路实现
```mermaid
graph TB
subgraph "组合逻辑电路实现"
DEC[操作码译码器] --> |"ADD"| AND1[与门]
TG[节拍发生器] --> |"T0"| AND1
AND1 --> |"控制信号"| OR[或门]
FLAG[标志] --> AND1
OR --> |"最终控制信号"| CTRL[控制信号输出]
end
```
### 10.1.4 组合逻辑设计特点
| 优点 | 缺点 |
|------|------|
| 速度快 | 电路复杂 |
| 设计灵活 | 不易修改 |
| 适合RISC | 扩展困难 |
---
## 10.2 微程序设计
### 10.2.1 微程序设计思想
> [!info] 核心思想
> 将每条机器指令的执行过程编写成一个微程序，存放在控制存储器中。
**基本概念**：
| 术语 | 定义 |
|------|------|
| **微命令** | 控制信号，控制微操作 |
| **微操作** | 由微命令控制的最基本操作 |
| **微指令** | 一组微命令的集合 |
| **微程序** | 微指令序列 |
| **控制存储器** | 存放微程序的存储器 |
```mermaid
graph TB
subgraph "微程序层次结构"
MACHINE[机器指令] --> |"对应"| MICRO_PROG[微程序]
MICRO_PROG --> |"包含"| MICRO_INST[微指令]
MICRO_INST --> |"包含"| MICRO_CMD[微命令]
MICRO_CMD --> |"控制"| MICRO_OP[微操作]
end
```
### 10.2.2 微程序控制单元框图
```mermaid
graph TB
subgraph "微程序控制单元"
IR[IR] --> |"操作码"| CMAR[控制存储器地址寄存器]
CMAR --> |"地址"| CM[控制存储器]
CM --> |"微指令"| CMDR[控制存储器数据寄存器]
CMDR --> |"微命令"| CTRL[控制信号]
CMDR --> |"下地址"| CMAR
SEQ[顺序逻辑] --> CMAR
end
```
**组成部分**：
- **控制存储器（CM）**：存放所有微程序
- **控制存储器地址寄存器（CMAR）**：存放微指令地址
- **控制存储器数据寄存器（CMDR）**：存放微指令
- **顺序逻辑**：产生下条微指令地址
### 10.2.3 微指令格式
#### 水平型微指令
```mermaid
graph LR
subgraph "水平型微指令"
CMD[操作控制字段] --> SEQ[顺序控制字段]
end
```
**特点**：
- 每个微命令占一位
- 并行性好，速度快
- 指令字长较长
#### 垂直型微指令
```mermaid
graph LR
subgraph "垂直型微指令"
OP[操作码] --> ADDR[地址码]
end
```
**特点**：
- 类似机器指令格式
- 指令字长较短
- 并行性差，速度慢
#### 混合型微指令
**特点**：
- 结合水平型和垂直型优点
- 兼顾速度和效率
### 10.2.4 微指令编码方式
#### 1. 直接编码
**特点**：每个微命令占一位，控制字段直接对应控制信号
**优点**：简单，并行性好
**缺点**：指令字长较长
#### 2. 字段直接编码
**特点**：将微命令分组，每组编码
**原则**：
- 互斥微命令在同一字段
- 相容微命令在不同字段
**优点**：减少指令字长
**缺点**：需要译码器
#### 3. 字段间接编码
**特点**：一个字段的含义取决于另一个字段
**优点**：进一步减少指令字长
**缺点**：译码复杂
### 10.2.5 微地址形成方式
| 方式 | 说明 | 应用 |
|------|------|------|
| **计数器方式** | CMAR自动加1 | 顺序执行 |
| **下地址字段** | 微指令中直接给出下地址 | 分支跳转 |
| **操作码映射** | 根据机器指令操作码映射 | 微程序入口 |
| **测试条件** | 根据条件选择地址 | 条件分支 |
### 10.2.6 微程序设计举例
#### 指令周期的微程序
```mermaid
graph TB
subgraph "取指周期微程序"
F1[PC → MAR, 1 → R] --> F2[M(MAR) → MDR, (PC)+1 → PC]
F2 --> F3[MDR → IR, OP(IR) → ID]
end
subgraph "执行周期微程序（加法指令）"
E1[Ad(IR) → MAR, 1 → R] --> E2[M(MAR) → MDR]
E2 --> E3[(ACC)+(MDR) → ACC]
end
F3 --> |"ADD"| E1
```
#### 微程序流程图
```mermaid
graph TB
START[开始] --> FETCH[取指周期微程序]
FETCH --> DECODE[指令译码]
DECODE --> |"ADD"| ADD[加法微程序]
DECODE --> |"STA"| STA[存数微程序]
DECODE --> |"LDA"| LDA[取数微程序]
DECODE --> |"JMP"| JMP[转移微程序]
ADD --> END[结束]
STA --> END
LDA --> END
JMP --> END
```
### 10.2.7 动态微程序设计
> [!info] 概念
> 微程序可根据需要动态改变，支持不同指令系统。
**特点**：
- 灵活性高
- 可支持不同指令集
- 硬件复杂
### 10.2.8 毫微程序设计
> [!info] 概念
> 用毫微程序解释微指令，进一步提高灵活性。
**层次结构**：
- 机器指令 → 微程序解释
- 微指令 → 毫微程序解释
### 10.2.9 微程序设计特点
| 优点 | 缺点 |
|------|------|
| 规整性好 | 速度较慢 |
| 易于修改 | 需要控制存储器 |
| 灵活性高 | 硬件成本增加 |
| 适合CISC | 设计复杂 |
---
## 10.3 两种设计方法比较
| 特性 | 组合逻辑设计 | 微程序设计 |
|------|--------------|------------|
| **速度** | 快 | 较慢 |
| **灵活性** | 差 | 好 |
| **规整性** | 差 | 好 |
| **修改** | 困难 | 容易 |
| **成本** | 较低 | 较高 |
| **应用** | RISC | CISC |
```mermaid
graph TB
subgraph "设计方法选择"
A[指令系统] --> B{复杂程度}
B -->|简单| C[组合逻辑设计]
B -->|复杂| D[微程序设计]
C --> E[RISC处理器]
D --> F[CISC处理器]
end
```
---
## 📝 本章小结
### 核心概念
1. **组合逻辑设计**：用组合逻辑电路实现控制单元
2. **微程序设计**：将控制信号编写成微程序
3. **微指令格式**：水平型、垂直型、混合型
4. **微指令编码**：直接编码、字段编码
### 关键公式
- **微指令字长**：$L = \sum_{i=1}^{n} \lceil \log_2(m_i + 1) \rceil$
- n：字段数
- m_i：第i字段的微命令数
### 重点图示
> [!summary] 必须掌握的内容
> 1. 组合逻辑控制单元框图
> 2. 微程序控制单元框图
> 3. 微指令格式和编码方式
> 4. 微程序流程图设计
---
## 🧪 自测练习
### 概念题
1. 比较组合逻辑设计和微程序设计的优缺点。
2. 说明微指令的编码方式。
3. 解释微程序设计的基本原理。
### 设计题
1. 设计一个简单指令的微程序。
2. 画出微程序控制单元的框图。
---
## 🔗 相关链接
- [[09_控制单元功能]] - 上一章
- [[08_CPU结构与功能]] - CPU结构
- [[07_指令系统]] - 指令格式
- [[00_计算机组成原理学习指南]] - 返回主目录
---
*本章难度：⭐⭐⭐⭐⭐ 困难*
*重要程度：⭐⭐⭐⭐⭐ 核心重点*

322
计算机组成原理/学习笔记/10_控制单元设计_补充版.md Normal file
View File

@@ -0,0 +1,322 @@
# 第10章 控制单元设计（详细补充版）
> 📖 本章介绍控制单元的两种设计方法：组合逻辑设计和微程序设计。
> 🎯 重点理解微程序设计方法
---
## 📋 本章目录
- [[#10.1 组合逻辑设计]]
- [[#10.2 微程序设计]]
- [[#本章小结]]
- [[#例题与解析]]
---
## 10.1 组合逻辑设计
### 10.1.1 组合逻辑控制单元框图
```mermaid
graph TB
subgraph "组合逻辑控制单元"
IR[IR<br/>指令寄存器] --> |"操作码"| DEC[操作码译码器]
CLK[时钟] --> |"时钟信号"| TG[节拍发生器]
DEC --> |"译码输出"| CU[控制单元]
TG --> |"节拍信号"| CU
FLAG[标志] --> CU
CU --> |"控制信号"| CTRL[控制信号输出]
end
```
组合逻辑控制单元由三个核心部件组成。操作码译码器负责把指令的操作码翻译成具体的控制信号——比如加法指令的码进来，就输出"做加法"的信号。节拍发生器产生时序信号，控制微操作的先后顺序，就像节拍器控制乐队的节奏。控制单元则是核心，它综合译码结果、节拍信号和标志位，在正确的时刻发出正确的控制信号。
这种设计方式的特点是速度快——信号通过逻辑门直接产生，不需要访问存储器。但缺点也很明显：电路复杂，修改困难，每增加一条指令可能都要重新设计电路。
### 10.1.2 微操作的节拍安排
安排微操作的节拍时，需要遵循三个原则。
**顺序原则**：有些微操作的次序不能改变。比如必须先送地址到MAR才能读内存，必须先读到MDR才能送到IR——这些顺序是硬件决定的，不能颠倒。
**并行原则**：不同控制对象的微操作可以同时执行。比如ALU做加法的同时，寄存器可以读数据——因为它们控制的是不同的硬件部件，互不干扰。
**紧凑原则**：时间短的微操作可以安排在同一节拍。比如PC送MAR和发读命令可以同时进行，因为它们的操作对象不同，而且都很快速。
#### 取指周期节拍安排
| 节拍 | 微操作 | 说明 |
|------|--------|------|
| T₀ | PC → MAR, 1 → R | 地址送MAR，发读命令 |
| T₁ | M(MAR) → MDR, (PC)+1 → PC | 读指令，PC加1 |
| T₂ | MDR → IR, OP(IR) → ID | 指令送IR，译码 |
```mermaid
sequenceDiagram
participant T0 as 节拍T0
participant T1 as 节拍T1
participant T2 as 节拍T2
Note over T0: PC → MAR, 1 → R
Note over T1: M(MAR) → MDR, (PC)+1 → PC
Note over T2: MDR → IR, OP(IR) → ID
```
三个节拍就完成了取指。T₀节拍同时做两件事：送地址和发读命令，因为它们操作的对象不同（MAR和控制总线），可以并行。T₁节拍也是两件事并行：从内存读指令到MDR，同时PC加1——读内存是主存的操作，PC加1是CPU内部操作，互不影响。T₂节拍把指令从MDR搬到IR，同时操作码送到译码器。
#### 间址周期节拍安排
| 节拍 | 微操作 | 说明 |
|------|--------|------|
| T₀ | Ad(IR) → MAR, 1 → R | 形式地址送MAR |
| T₁ | M(MAR) → MDR | 读有效地址 |
| T₂ | MDR → Ad(IR) | 有效地址送IR |
间址周期和取指周期结构类似，但目的不同——这里是为了获取有效地址。T₀送形式地址并发读命令，T₁从内存读有效地址到MDR，T₂把有效地址写回指令的地址字段。这样后续执行周期就知道该去哪操作了。
#### 执行周期节拍安排
**非访存指令**不需要访问内存，所以很多只需要用到T₂节拍：
| 指令 | T₀ | T₁ | T₂ |
|------|----|----|-----|
| CLA | 空 | 空 | 0 → ACC |
| COM | 空 | 空 | $\overline{ACC}$ → ACC |
| SHR | 空 | 空 | L(ACC) → R(ACC) |
| CSL | 空 | 空 | R(ACC) → L(ACC) |
| STP | 空 | 空 | 0 → G |
这些指令都是CPU内部操作，不需要去内存取数据，所以T₀和T₁空闲，只在T₂执行一个操作。这也是为什么非访存指令通常比访存指令快。
**访存指令**需要访问内存，三个节拍都用满了：
**加法指令 ADD X**：
| 节拍 | 微操作 |
|------|--------|
| T₀ | Ad(IR) → MAR, 1 → R |
| T₁ | M(MAR) → MDR |
| T₂ | (ACC) + (MDR) → ACC |
T₀送地址并发读命令，T₁从内存读操作数到MDR，T₂把累加器的值和MDR的值送到ALU做加法，结果写回累加器。
**存数指令 STA X**：
| 节拍 | 微操作 |
|------|--------|
| T₀ | Ad(IR) → MAR, 1 → W |
| T₁ | ACC → MDR |
| T₂ | MDR → M(MAR) |
STA X 和 ADD X 的区别在于方向：ADD 是从内存读到CPU，STA 是从CPU写到内存。所以T₀发的是写命令（1→W），T₁把累加器的值送到MDR，T₂把MDR的内容写入内存。
**取数指令 LDA X**：
| 节拍 | 微操作 |
|------|--------|
| T₀ | Ad(IR) → MAR, 1 → R |
| T₁ | M(MAR) → MDR |
| T₂ | MDR → ACC |
LDA X 和 ADD X 的前三步完全一样，区别在T₂：ADD 是做加法后送回累加器，LDA 是直接把MDR的值送到累加器（累加器原来的值被覆盖）。
---
## 10.2 微程序设计
### 10.2.1 微程序设计的基本概念
> [!info] 定义
> 微程序设计是用程序的方法来设计控制单元，把控制信号编成微指令，存放在控制存储器中。
组合逻辑设计虽然速度快，但电路复杂、修改困难。微程序设计的思路完全不同——它把控制信号看成"数据"，存到一个ROM（只读存储器）里，执行指令时从ROM中读取控制信号。这样设计控制单元就变成了编写"微程序"，和写软件的思路类似。
三个核心概念：**微指令**是一组控制信号的集合，一条微指令可以同时激活多个控制信号；**微程序**是微指令的有序序列，一条机器指令对应一个微程序；**控制存储器**（CS）是存放微程序的ROM，通常在CPU内部。
举个例子，执行一条加法指令，它的微程序可能包含三条微指令：第一条完成取指（PC→MAR、1→R等），第二条完成取操作数（Ad(IR)→MAR、M(MAR)→MDR），第三条完成加法运算（(ACC)+(MDR)→ACC）。每条微指令里的控制信号可以并行发出。
### 10.2.2 微指令的格式
微指令由两部分组成：**操作控制字段**产生各种控制信号，**顺序控制字段**决定下一条微指令的地址。
根据操作控制字段的编码方式，微指令分为两种格式。
**水平型微指令**的操作控制字段很长，每一位（或每几位）对应一个控制信号，可以同时激活多个信号，实现并行操作。优点是执行速度快（一条微指令就能完成很多操作），缺点是微指令很长，占用存储空间大。现代高性能CPU通常采用水平型微指令。
**垂直型微指令**的操作控制字段很短，采用编码方式，一条微指令只能控制一个或少数几个操作。优点是微指令短、节省空间，缺点是执行速度慢（需要更多微指令才能完成一条机器指令）。简单处理器常用垂直型微指令。
### 10.2.3 微程序设计的步骤
微程序设计可以分为四步。
第一步是**分析指令**：把每条机器指令分解成微操作序列，确定需要哪些控制信号。比如加法指令需要PC→MAR、1→R、M(MAR)→MDR、(ACC)+(MDR)→ACC这些控制信号。
第二步是**设计微指令格式**：确定操作控制字段和顺序控制字段的宽度和编码方式。操作控制字段要能表示所有需要的控制信号，顺序控制字段要能表示微程序的地址范围。
第三步是**编写微程序**：为每条机器指令编写对应的微程序。取指周期的微程序是所有指令共用的，执行周期的微程序因指令而异。
第四步是**实现控制存储器**：把微程序固化到ROM中。ROM的内容在制造时就确定了，不能修改（除非用可擦写的EPROM）。
### 10.2.4 微程序设计的优缺点
微程序设计最大的优点是**规整性和灵活性**。用程序的方法设计控制单元，逻辑清晰、容易理解；需要增加新指令时，只需要在ROM中添加对应的微程序，不需要重新设计电路；调试和维护也方便，可以通过修改微程序来修复bug。
缺点主要是**速度**。每条微指令都要从控制存储器读取，增加了访存时间，比组合逻辑直接产生信号要慢。另外需要额外的控制存储器，增加了硬件成本。
实际应用中，现代复杂CPU（如x86系列）通常采用微程序设计，因为指令集复杂、需要灵活扩展。而简单处理器（如一些嵌入式处理器）可能采用组合逻辑设计，追求更高的执行速度。
---
## 📝 本章小结
### 核心概念
1. **组合逻辑设计**：用组合逻辑电路直接产生控制信号，速度快但设计复杂
2. **微程序设计**：把控制信号存到ROM中，用读取ROM的方式产生控制信号，灵活但速度较慢
3. **微指令**：一组控制信号的集合
4. **微程序**：微指令的有序序列，一条机器指令对应一个微程序
5. **控制存储器**：存放微程序的ROM
### 关键术语
| 术语 | 英文 | 含义 |
|------|------|------|
| 组合逻辑 | Combinational Logic | 用逻辑电路实现 |
| 微程序 | Microprogram | 用程序实现 |
| 微指令 | Microinstruction | 控制信号的集合 |
| 控制存储器 | Control Storage | 存放微程序的ROM |
### 重点图示
> [!summary] 必须掌握的图
> 1. 组合逻辑控制单元框图
> 2. 微程序控制单元框图
> 3. 微指令格式图
> 4. 取指周期的节拍安排图
---
## 🧪 例题与解析
### 例题1：取指周期节拍安排
**题目**：写出取指周期的节拍安排。
**答案**：
| 节拍 | 微操作 | 说明 |
|------|--------|------|
| T₀ | PC → MAR, 1 → R | 地址送MAR，发读命令 |
| T₁ | M(MAR) → MDR, (PC)+1 → PC | 读指令，PC加1 |
| T₂ | MDR → IR, OP(IR) → ID | 指令送IR，译码 |
每个节拍都安排了两个可以并行的操作：T₀送地址和发读命令操作对象不同，可以同时进行；T₁读内存和PC加1一个是主存操作、一个是CPU内部操作，互不干扰；T₂送指令和译码也是类似道理。这样三个节拍就完成了取指，效率很高。
### 例题2：加法指令节拍安排
**题目**：写出加法指令 ADD X 的节拍安排。
**答案**：
| 节拍 | 微操作 |
|------|--------|
| T₀ | Ad(IR) → MAR, 1 → R |
| T₁ | M(MAR) → MDR |
| T₂ | (ACC) + (MDR) → ACC |
ADD X 的执行周期需要三次访存操作中的两次（送地址、读数据），然后做加法。T₀送地址并发读命令，T₁等待内存响应并把数据读到MDR，T₂把累加器的值和MDR的值送到ALU做加法，结果写回累加器。如果X是间接寻址的，还需要在前面加一个间址周期。
### 例题3：微程序设计步骤
**题目**：简述微程序设计的步骤。
**答案**：
微程序设计的步骤：
1. **分析指令**：把每条机器指令分解成微操作序列，确定需要哪些控制信号
2. **设计微指令格式**：确定操作控制字段和顺序控制字段的宽度和编码方式
3. **编写微程序**：为每条机器指令编写对应的微程序，取指周期的微程序是共用的
4. **实现控制存储器**：把微程序固化到ROM中
这四步的核心思想是"用数据代替逻辑"——把原本需要复杂电路实现的控制逻辑，变成存储在ROM中的数据，通过读取ROM来产生控制信号。这样设计更灵活，但代价是速度稍慢。
### 例题4：组合逻辑与微程序比较
**题目**：比较组合逻辑设计和微程序设计的优缺点。
**答案**：
| 特性 | 组合逻辑设计 | 微程序设计 |
|------|--------------|------------|
| **设计方法** | 用逻辑电路直接实现 | 用程序（ROM）实现 |
| **优点** | 速度快 | 规整性好，灵活，易修改 |
| **缺点** | 设计复杂，不灵活，难修改 | 速度较慢，需要额外的ROM |
| **应用** | 简单CPU、RISC处理器 | 复杂CPU、CISC处理器 |
选择哪种方式取决于设计目标：追求极致速度就用组合逻辑，追求灵活性和可扩展性就用微程序。现代CPU往往混合使用——简单常用的指令用组合逻辑加速，复杂指令用微程序实现。
### 例题5：微指令格式设计
**题目**：设计一个简单的微指令格式，支持8种控制信号。
**答案**：
**操作控制字段**：8种控制信号，如果采用水平型编码（每位对应一个信号），需要8位。如果采用垂直型编码（用3位二进制编码选择8种信号之一），只需要3位，但一次只能激活一个信号。
**顺序控制字段**：需要支持顺序执行和跳转。假设微程序最多16条微指令，地址需要4位；再加1位跳转标志（是否跳转），共5位。
**水平型微指令格式**（16位）：
- 操作控制字段：8位（每位控制一个信号，可同时激活多个）
- 顺序控制字段：4位地址 + 1位跳转标志 + 3位备用 = 8位
**垂直型微指令格式**（8位）：
- 操作控制字段：3位（编码选择8种信号之一）
- 顺序控制字段：4位地址 + 1位跳转标志 = 5位
水平型微指令更灵活（一条指令可以同时控制多个操作），但占用更多空间；垂直型微指令更紧凑，但需要更多条微指令才能完成同样的功能。
---
## ⚡ 知识点速记卡
> 考前快速过一遍，30秒回忆整章核心
**两种CU设计方法**：组合逻辑（硬连线，快但难改）vs 微程序（ROM存控制信号，灵活但慢）。
**组合逻辑CU三部件**：操作码译码器（指令→控制信号）、节拍发生器（产生时序）、控制单元（综合输出）。
**节拍安排三原则**：顺序原则（先MAR后读内存）、并行原则（不同部件可同时工作）、紧凑原则（短操作放同一节拍）。
**取指周期三拍**：T₀=PC→MAR+1→R，T₁=M(MAR)→MDR+(PC)+1→PC，T₂=MDR→IR+OP(IR)→ID。
**微程序核心三概念**：微指令（一组控制信号）、微程序（微指令序列，一条机器指令对应一个微程序）、控制存储器CS（存微程序的ROM）。
**水平型 vs 垂直型微指令**：水平型（位长，可并行多信号，快但占空间）vs 垂直型（位短，编码方式，省空间但慢）。
**微程序设计四步**：分析指令→设计微指令格式→编写微程序→固化到ROM。核心思想：用数据（ROM）代替逻辑（电路）。
**选择策略**：追求速度→组合逻辑（RISC），追求灵活→微程序（CISC）。现代CPU常混合使用。
---
## 🔗 相关链接
- [[00_计算机组成原理学习指南]] - 返回主目录
- [[09_控制单元功能]] - 上一章
- [[01_计算机系统概论]] - 返回第一章
---
## 📚 参考资料
- 教材：《计算机组成原理》第3版 - 唐朔飞
- 复习资料：计算机组成原理知识点总结
- 习题：作业三、作业四
---
*本章难度：⭐⭐⭐⭐⭐ 困难*
*重要程度：⭐⭐⭐⭐⭐ 重点*
*补充版本：增加了通俗解释、实际例子和例题*

149
计算机组成原理/学习笔记/README.md Normal file
View File

@@ -0,0 +1,149 @@
# 计算机组成原理学习笔记
> 📚 基于唐朔飞《计算机组成原理》第3版整理
> 🎯 适合初学者系统学习和考前快速复习
> 📝 符合Obsidian笔记软件格式
---
## 📖 笔记目录
| 文件 | 内容 | 难度 | 重要程度 |
|------|------|------|----------|
| [[00_计算机组成原理学习指南]] | 学习指南和整体框架 | ⭐ | ⭐⭐⭐ |
| [[01_计算机系统概论]] | 计算机系统基础概念 | ⭐⭐ | ⭐⭐⭐ |
| [[03_系统总线]] | 总线结构和工作原理 | ⭐⭐⭐ | ⭐⭐⭐ |
| [[04_存储器]] | 存储系统层次结构 | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| [[05_输入输出系统]] | IO系统工作方式 | ⭐⭐⭐ | ⭐⭐⭐⭐ |
| [[06_运算方法]] | 数据的表示和运算 | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| [[07_指令系统]] | 指令格式和寻址方式 | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ |
| [[08_CPU结构与功能]] | CPU组成和工作原理 | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| [[09_控制单元功能]] | 控制单元的基本功能 | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ |
| [[10_控制单元设计]] | 控制单元的设计方法 | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
---
## 🎯 学习建议
### 初学者学习路径
```
第1章 概论 → 第3章 总线 → 第7章 指令系统 → 第6章 运算方法
↓
第4章 存储器 → 第5章 IO系统 → 第8章 CPU → 第9-10章 控制单元
```
### 复习者快速回顾
1. **重点章节**：第4章（存储器）、第6章（运算方法）、第8章（CPU）、第10章（控制单元设计）
2. **核心概念**：冯·诺依曼体系、存储层次、指令周期、微程序设计
3. **必考内容**：补码运算、Cache映射、中断处理、微指令格式
---
## 📊 重要公式速查
### 数制转换
- 二进制 → 十进制：$\sum_{i=0}^{n} a_i \times 2^i$
- 十进制 → 二进制：除2取余，乘2取整
### 数据表示
- 原码范围：$-(2^{n-1}-1) \sim +(2^{n-1}-1)$
- 补码范围：$-2^{n-1} \sim +(2^{n-1}-1)$
- 移码：$[x]_{移} = 2^{n-1} + x$
### Cache相关
- Cache命中率：$H = \frac{N_c}{N_c + N_m}$
- 平均访问时间：$T_a = HT_c + (1-H)T_m$
- 访问效率：$e = \frac{T_c}{T_a}$
### 浮点数
- IEEE 754：$N = (-1)^S \times 1.M \times 2^{E-127}$
### 流水线
- 加速比：$S = \frac{n \times k}{k + (n-1)}$
---
## 📝 笔记使用说明
### Obsidian特性使用
1. **双链链接**：使用 `[[文件名]]` 创建笔记间链接
2. **Callout提示**：使用 `> [!info]`、`> [!tip]` 等创建提示框
3. **Mermaid图表**：使用 ````mermaid` 创建流程图、时序图等
4. **数学公式**：使用 `$...$` 行内公式，`$$...$$` 块级公式
5. **标签**：使用 `#标签` 对笔记分类
### 推荐标签
- `#计算机组成` - 主标签
- `#重点` - 重点内容
- `#公式` - 重要公式
- `#图例` - 图示说明
- `#习题` - 练习题
---
## 🔧 实验资源
- 实验1：中规模组合电路及运算器的应用
- 实验3：基本模型机的数据通路
- 实验4：基本模型机的微程序设计
---
## 📚 参考资料
- 教材：《计算机组成原理》第3版 - 唐朔飞
- 复习资料：1-10章精简参考复习资料
- 习题：作业三、作业四
- 试卷：样卷2025、期中考试
---
## 💡 学习小贴士
> [!tip] 理解优先
> 计算机组成原理重在理解硬件工作原理，不要死记硬背。多画图、多思考数据流向。
> [!warning] 常见误区
> - 混淆计算机体系结构和计算机组成的概念
> - 不理解补码运算的本质
> - 忽视存储层次的整体性
> [!note] 考试重点
> - 补码加减运算及溢出判断
> - Cache地址映射和替换算法
> - 中断处理过程
> - 微程序设计方法
---
## 📁 文件结构
```
学习笔记/
├── README.md # 本文件
├── 00_计算机组成原理学习指南.md # 学习指南
├── 01_计算机系统概论.md # 第1章
├── 03_系统总线.md # 第3章
├── 04_存储器.md # 第4章
├── 05_输入输出系统.md # 第5章
├── 06_运算方法.md # 第6章
├── 07_指令系统.md # 第7章
├── 08_CPU结构与功能.md # 第8章
├── 09_控制单元功能.md # 第9章
└── 10_控制单元设计.md # 第10章
```
---
*笔记整理完成：2026年7月4日*
*总文件数：11个*
*总字数：约10万字*

219
计算机组成原理/学习笔记/README_补充版说明.md Normal file
View File

@@ -0,0 +1,219 @@
# 计算机组成原理学习笔记 - 补充版说明
## 📋 补充工作概述
我已经为计算机组成原理学习笔记的每个章节创建了详细补充版，增加了通俗易懂的解释、实际例子和例题，帮助更好地理解课程中的难点。
## 📚 补充版笔记列表
| 章节 | 基础版 | 补充版 | 主要补充内容 |
|------|--------|--------|--------------|
| 第1章 | 01_计算机系统概论.md | 01_计算机系统概论_补充版.md | 计算机层次结构、冯·诺依曼体系 |
| 第3章 | 03_系统总线.md | 03_系统总线_补充版.md | 总线结构、总线仲裁、总线控制 |
| 第4章 | 04_存储器.md | 04_存储器_补充版.md | 存储层次、Cache、虚拟存储器 |
| 第5章 | 05_输入输出系统.md | 05_输入输出系统_补充版.md | 程序查询、中断、DMA |
| 第6章 | 06_运算方法.md | 06_运算方法_补充版.md | 补码运算、浮点数表示 |
| 第7章 | 07_指令系统.md | 07_指令系统_补充版.md | 寻址方式、指令格式、RISC |
| 第8章 | 08_CPU结构与功能.md | 08_CPU结构与功能_补充版.md | CPU结构、指令周期、流水线 |
| 第9章 | 09_控制单元功能.md | 09_控制单元功能_补充版.md | 微操作命令、控制单元功能 |
| 第10章 | 10_控制单元设计.md | 10_控制单元设计_补充版.md | 组合逻辑设计、微程序设计 |
## 🎯 补充版特点
### 1. 通俗易懂的解释
- 用日常生活中的例子解释抽象概念
- 用类比的方法帮助理解难点
- 避免使用过于专业的术语
### 2. 实际例子
- 每个概念都有对应的实际例子
- 帮助理解理论在实际中的应用
- 增强学习的趣味性
### 3. 详细例题
- 每个章节都有5道例题
- 包含详细的解题步骤和答案
- 帮助掌握考试重点
### 4. 深入浅出的讲解
- 从简单到复杂，循序渐进
- 帮助建立完整的知识体系
- 强调重点和难点
## 📖 如何使用补充版笔记
### 初学者学习路径
1. 先阅读基础版笔记，了解基本概念
2. 再阅读补充版笔记，加深理解
3. 做补充版笔记中的例题，巩固知识
4. 遇到不理解的地方，参考补充版笔记中的解释
### 复习者快速回顾
1. 快速浏览基础版笔记，回顾知识点
2. 重点阅读补充版笔记中的例题
3. 做补充版笔记中的例题，检验掌握程度
4. 针对薄弱环节，重点复习补充版笔记
### 考试前重点复习
1. 重点复习补充版笔记中的例题
2. 理解解题思路和方法
3. 掌握考试重点和难点
4. 做模拟试题，检验复习效果
## 🔍 补充内容详解
### 第1章：计算机系统概论
**补充重点**：
- 计算机层次结构的通俗解释
- 冯·诺依曼体系的实际例子
- 计算机体系结构与组成的区别
- 编译程序与解释程序的比较
**例题类型**：
- 计算机层次结构分析
- 编译与解释程序比较
- 冯·诺依曼体系特点
- 技术指标计算
### 第3章：系统总线
**补充重点**：
- 总线的通俗解释（公共马路）
- 三种总线结构的比较
- 总线仲裁的实际例子
- 总线性能指标的计算
**例题类型**：
- 总线带宽计算
- 地址总线计算
- 总线结构比较
- 总线仲裁分析
### 第4章：存储器
**补充重点**：
- 存储层次的通俗解释（办公室文件系统）
- SRAM与DRAM的比较
- Cache工作原理的实际例子
- 虚拟存储器的概念
**例题类型**：
- 存储容量计算
- Cache命中率计算
- Cache地址映射
- 存储器扩展
### 第5章：输入输出系统
**补充重点**：
- I/O系统发展的通俗解释
- 三种I/O方式的比较
- 中断处理过程的实际例子
- DMA工作原理
**例题类型**：
- 中断处理过程分析
- DMA与中断比较
- 程序查询方式分析
- 中断优先级设计
### 第6章：运算方法
**补充重点**：
- 补码的通俗解释（时钟例子）
- 四种编码的比较
- 浮点数表示的实际例子
- 定点运算和浮点运算
**例题类型**：
- 补码计算
- 浮点数表示
- 补码加法
- 溢出判断
### 第7章：指令系统
**补充重点**：
- 指令格式的通俗解释
- 各种寻址方式的实际例子
- RISC与CISC的比较
- 扩展操作码设计
**例题类型**：
- 指令格式设计
- 寻址方式分析
- RISC与CISC比较
- 扩展操作码设计
### 第8章：CPU结构与功能
**补充重点**：
- CPU功能的通俗解释
- CPU结构的实际例子
- 指令周期的概念
- 指令流水线的原理
**例题类型**：
- CPU功能分析
- 指令周期计算
- 流水线性能计算
- 流水线冲突分析
### 第9章：控制单元功能
**补充重点**：
- 微操作命令的通俗解释
- 指令周期四个阶段的实际例子
- 各种指令的微操作序列
- 控制单元的功能
**例题类型**：
- 取指周期分析
- 间址周期分析
- 加法指令分析
- 控制单元功能分析
### 第10章：控制单元设计
**补充重点**：
- 组合逻辑设计的通俗解释
- 微程序设计的实际例子
- 微指令格式的设计
- 两种设计方法的比较
**例题类型**：
- 取指周期节拍安排
- 加法指令节拍安排
- 微程序设计步骤
- 组合逻辑与微程序比较
## 📊 学习建议
### 重点章节
1. **第4章 存储器**：Cache映射、虚拟存储器
2. **第6章 运算方法**：补码运算、浮点数表示
3. **第8章 CPU结构与功能**：指令周期、流水线
4. **第10章 控制单元设计**：微程序设计
### 难点突破
1. **补码运算**：用时钟例子理解补码概念
2. **Cache映射**：用图书馆书架例子理解映射方式
3. **流水线**：用工厂生产线理解流水线原理
4. **微程序设计**：用程序控制机器理解微程序概念
### 考试重点
1. **补码加减运算及溢出判断**
2. **Cache地址映射和替换算法**
3. **中断处理过程**
4. **微程序设计方法**
## 📝 学习小贴士
1. **理解优先**：不要死记硬背，要理解原理
2. **多画图**：用图形帮助理解抽象概念
3. **多思考**：思考数据流向和控制信号
4. **多练习**：做例题巩固知识
5. **多总结**：总结知识点和解题方法
## 🔗 相关资源
- 教材：《计算机组成原理》第3版 - 唐朔飞
- 复习资料：计算机组成原理知识点总结
- 习题：作业三、作业四
- 试卷：样卷2025、期中考试
---
*补充版笔记创建完成，希望对学习有所帮助！*