第 1 章计算机系统概述

408 计算机组成原理第 1 章计算机系统概述复习讲义，涵盖核心概念、重点考点与典型题型。

这一章的定位是给整本计算机组成原理搭骨架。资料中的考纲主要分成两部分：一是计算机系统层次结构，包括硬件、软件、存储程序、语言转换和程序执行过程；二是计算机性能指标，包括吞吐量、响应时间、时钟周期、主频、CPI、CPU 执行时间、MIPS 和 FLOPS 等。

从历年真题看，第一章虽然篇幅不大，但考点非常稳定：2009、2015、2016、2019、2022、2023、2024 年都考过系统层次、冯·诺依曼结构或程序翻译；2010—2014、2017、2020—2023 年又反复考 CPU 性能指标。尤其是 CPU 执行时间公式，是这一章最值得熟练到条件反射的内容。

一、先建立第一章的总框架

可以把这一章理解成下面这一条主线：

人要解决的问题
      ↓
算法
      ↓
高级语言程序，如 C
      ↓
编译、汇编、链接
      ↓
机器语言程序
      ↓
ISA：规定机器指令长什么样、能做什么
      ↓
CPU 取指 → 译码 → 执行
      ↓
ALU、寄存器、主存、I/O 等硬件真正动作

所以本章实际上回答三个问题：

第一，计算机到底由什么构成？

硬件 + 软件。

第二，我们写的 C 程序为什么能让晶体管工作？

高级语言经过层层翻译变成机器指令，CPU 按 ISA 规定执行机器指令。

第三，两台 CPU 谁更快，到底怎么判断？

不能只看主频，要综合看：

指令条数

CPI

主频

最终落到：

T_{CPU} = \frac{指令条数 \times CPI}{主频}

这三条把第一章基本串起来了。

二、1.1 计算机发展历程——低频，理解为主

这部分不是第一章的核心计算内容，复习时不要投入过多时间。

1. 四代计算机

资料按主要逻辑元件把计算机分为四代。

代次	主要逻辑元件	典型变化
第一代	电子管	机器语言、体积大、功耗大、速度低
第二代	晶体管	磁芯存储器、高级语言开始发展
第三代	中小规模集成电路	半导体存储器逐步普及、操作系统发展
第四代	大规模/超大规模集成电路	微处理器、Cache、流水线、虚拟存储等

考试若考，通常是对应关系选择题，而不是让你背完整年代。

例如看到：

“微处理器开始出现”

优先想到第四代。

看到：

“主要逻辑元件为晶体管”

就是第二代。

2. 字长是什么

资料提到 32 位、64 位处理器中的“位”，通常指机器字长，也就是 CPU 通用寄存器的典型宽度。

可以先把字长理解为：

CPU 最自然、最擅长一次处理的二进制数据宽度。

例如一个典型 64 位 CPU，其通用寄存器可以一次容纳 64 bit 数据。

但有一个特别容易错的地方：

64 位 CPU ≠ 所有部件都是 64 位。

比如：

指令寄存器位数取决于指令格式；
地址总线位数取决于地址空间设计；
浮点寄存器甚至可能是 128 bit、256 bit、512 bit。

2020 年真题专门考过“哪些部件宽度一定与机器字长相同”。

三、1.2 计算机系统层次结构

这一部分属于高频概念区。

四、计算机系统 = 硬件 + 软件

资料明确指出，一个完整的计算机系统由硬件与软件共同组成。

硬件就是实际存在的物理设备，例如：

CPU
主存
Cache
硬盘
键盘
显示器
网卡
总线

软件则包括程序、数据及相关文档。

因此：

“计算机系统就是硬件系统。”

错误。

模拟题中就专门设置过这一陷阱。

五、软硬件的逻辑功能等价性

这是一个容易被忽略但非常重要的思想。

某项功能既可能：

用硬件实现

也可能：

用软件实现

只要最终达到同样的逻辑效果。

例如浮点运算。

可以设计专门的浮点运算器：

硬件直接完成浮点运算

也可以没有专门硬件：

软件通过若干整数指令模拟浮点运算

逻辑功能都可以实现。

区别主要是：

硬件：通常快，但设计成本高、灵活性差
软件：通常慢，但灵活、容易修改

所以计算机组成原理中有一个贯穿全书的思想：

时间、空间、成本、灵活性之间不断进行权衡。

六、冯·诺依曼计算机——第一章第一大高频考点

资料特别标出了这一部分，2019 年统考也直接考过。

冯·诺依曼机最核心的不是“五大部件”，而是：

存储程序。

所谓存储程序：

程序执行以前，先把：

程序指令
+
程序所需数据

放进主存。

随后计算机自动：

取一条指令
↓
执行
↓
取下一条
↓
执行
↓
……

不用人手工一条条告诉 CPU 做什么。

1. 五大部件

经典冯·诺依曼机由：

部件	作用
运算器	算术运算、逻辑运算
控制器	控制程序执行
存储器	存储程序和数据
输入设备	输入信息
输出设备	输出信息

现代计算机通常把：

运算器
+
控制器
+
寄存器

集成到 CPU 中。

七、CPU 内部到底有什么

资料将现代 CPU 理解为：

数据通路
+
控制单元

数据通路

可以理解为：

真正让数据“流动 + 运算”的硬件。

核心包括：

ALU
寄存器
内部总线
多路选择器

ALU 负责真正算：

加
减
与
或
异或
移位
比较

寄存器负责暂存数据。

控制单元

控制单元本身不是主要拿来“算数字”的，而是负责：

指挥其他部件什么时候做什么。

比如执行：

R3 ← R1 + R2

控制器可能依次产生控制信号：

读 R1
读 R2
↓
送入 ALU
↓
ALU 选择加法
↓
结果写入 R3

后面 CPU 章节学“控制信号”“数据通路”“微操作”时，本章这些概念就会重新出现。

八、冯·诺依曼机中指令和数据为什么能存在一起

这是非常高频的陷阱。

资料强调：

指令和数据在存储器中都采用二进制形式，形式上没有区别。

比如内存中：

10110000 00101101

你只看这一串 0 和 1，本身不能知道：

它是一条指令？
还是整数？
还是地址？
还是字符？

必须根据 CPU 当前执行过程进行解释。

2009 真题的核心

真题问：

冯·诺依曼机中指令和数据均以二进制存放，CPU 根据什么区分它们？

本质答案：

根据它们在指令执行过程中所处的阶段和使用方式。

取指阶段，从 PC 指定地址取出来的内容被当作指令。

执行阶段，根据指令的寻址要求取出来的内容被当作数据。

所以千万不要认为：

某一段内存固定只能存指令
另一段内存固定只能存数据

经典冯·诺依曼结构本身没有这种硬性物理区分。

九、冯·诺依曼结构和哈佛结构

这个知识在后面也可能出现。

经典冯·诺依曼结构：

指令
   \
    → 同一存储系统
   /
数据

哈佛结构：

指令 → 指令存储器

数据 → 数据存储器

所以题目如果说：

“指令存储器和数据存储器彼此分离是经典冯·诺依曼计算机的特点。”

就是错误的。

模拟题中也出现过这一考法。

十、指令是什么

在第一章只需要形成基本概念。

机器指令一般可以抽象成：

操作码 + 地址码

操作码回答：

做什么？

例如：

ADD
SUB
LOAD
STORE

地址码回答：

对谁操作？操作数在哪里？

后面的指令系统章节会详细讲。

十一、计算机语言层次——高频

资料把编程语言大致分为：

类型	能否 CPU 直接执行	特点
机器语言	能	二进制机器指令
汇编语言	不能	用助记符表示机器指令
高级语言	不能	更接近人的表达方式

这是 2015 年真题考过的经典点：

计算机硬件可以直接执行什么？

答案只有：

机器语言程序。

CPU 不直接执行：

C
C++
Java 源代码
汇编源程序

最终必须转换成 CPU 所能识别的机器指令。

十二、汇编器、编译器、解释器一定要分清

这是非常经典的选择题考点。2016 年统考和模拟题都考过。

程序	输入	输出/行为
汇编程序	汇编语言	机器语言目标代码
编译程序	高级语言	整体翻译成低级目标程序
解释程序	高级语言	翻译一句、执行一句
链接程序	多个目标模块/库	可执行文件

最容易混的是：

编译

整个源程序
↓
翻译
↓
目标程序
↓
之后运行

解释

读一句
↓
翻译
↓
执行
↓
再读下一句

因此解释器通常不生成一个独立的完整目标程序。

十三、从 C 程序到可执行文件——超级高频

资料把 GCC 的典型过程分成四阶段：

预处理
↓
编译
↓
汇编
↓
链接

2022 年统考直接考过这个顺序。

假设有：

hello.c

完整流程可以理解为：

hello.c
   │
   │ 预处理
   ▼
hello.i
   │
   │ 编译
   ▼
hello.s
   │
   │ 汇编
   ▼
hello.o
   │
   │ 链接
   ▼
hello
可执行文件

1. 预处理

处理：

#include
#define
#if
#ifdef

例如：

#include <stdio.h>

预处理器会展开相关内容。

关键点：

预处理不是编译。

2. 编译

把高级语言：

a = b + c;

转换成汇编层面的指令描述。

例如概念上：

mov ...
add ...

因此注意：

编译输出不一定已经是最终机器码。

资料示例中编译器得到：

hello.s

3. 汇编

汇编器把：

mov
add
sub

等助记符翻译成机器码。

产生类似：

hello.o

这叫可重定位目标文件。

注意：

hello.o 通常仍不等于最终能直接启动的完整程序。

4. 链接

假设程序调用：

printf()

但 printf 的真正机器代码不一定在你的 hello.o 中。

链接器要把：

hello.o
printf 所在库
其他目标模块

整合起来，同时完成符号解析和地址重定位，最后得到可执行文件。

所以记忆：

编译解决“翻译”，链接解决“拼起来”。

十四、ISA 是什么——特别重要的“软硬件接口”

ISA 全称：

Instruction Set Architecture，指令集体系结构。

资料把 ISA 定义为：

软件和硬件之间的关键接口。

可以把它想成 CPU 和软件签订的一份“合同”。

软件问：

你这个 CPU 支持哪些指令？
有哪些寄存器？
指令格式是什么？
有哪些数据类型？
有哪些寻址方式？

ISA 给出答案。

ISA 和微体系结构必须分开

这是理解现代 CPU 的关键。

ISA：规定“做什么”

例如：

支持 ADD 指令
支持 LOAD 指令
有若干通用寄存器

微体系结构：规定“怎么做”

例如：

几级流水线
多大的 Cache
怎样做分支预测
几个执行单元
ALU 如何实现

因此：

同一 ISA 可以有完全不同的 CPU 内部实现。

比如不同 x86 CPU 可以运行相同机器程序，但：

流水线
Cache
执行单元
分支预测

可能完全不同。

这就是：

ISA = 软件能看到的接口
微体系结构 = 内部怎么实现这个接口

十五、“透明”是什么意思

组成原理中后面会经常看到这个词。

所谓：

A 对 B 透明

就是：

B 不需要知道 A 的内部细节。

例如 ISA 以下的具体电路实现，对高级语言程序员通常是透明的。

写：

c = a + b;

程序员一般不需要知道 CPU 内部到底是：

串行进位加法器
还是
超前进位加法器

只要 ISA 保证“加法”的语义即可。

十六、存储程序到底怎样自动执行——必须真正理解

这是第一章理解 CPU 的核心。

假设内存中放着：

地址100：指令1
地址104：指令2
地址108：指令3
……

CPU 中有一个非常重要的寄存器：

PC
Program Counter
程序计数器

PC 保存：

下一条将要执行的指令地址。

假设：

PC = 100

CPU 会经历：

PC 给出地址 100
        ↓
访问主存
        ↓
取得指令1
        ↓
译码
        ↓
取操作数
        ↓
执行
        ↓
写回结果
        ↓
更新 PC

然后继续。

十七、PC 怎么更新

如果当前是普通顺序指令：

P C_{new} = P C_{old} + 当前指令长度

例如一条指令长 4B：

100 → 104 → 108 → 112

但是遇到：

if
for
while
goto
函数调用

最终会出现跳转类机器指令。

此时：

P C_{new} = 跳转目标地址

于是 CPU 不再执行物理上紧挨着的下一条指令，而是跳到目标位置。

这就是高级语言里的：

if
while
for

最终如何改变 CPU 指令流的基本原理。

资料也明确以 PC 为核心描述了这一自动执行过程。

十八、1.3 计算机性能指标——第一章最重要部分

如果第一章只能重点掌握一部分，建议就是这里。

资料和历年真题都高度集中在：

主频
时钟周期
CPI
指令条数
CPU 执行时间
MIPS
FLOPS

十九、吞吐量和响应时间

两者都叫“性能”，但不是一回事。

指标	核心问题
响应时间	一个任务多久完成？
吞吐量	单位时间完成多少任务？

例如服务器：

原来 1 秒处理 1000 请求
现在 1 秒处理 2000 请求

吞吐量提高。

但某个请求：

原来 100 ms 返回
现在还是 100 ms

响应时间没有改善。

所以：

吞吐量提高不意味着单个程序响应时间一定降低。

二十、时钟周期与主频

CPU 是按照时钟节拍工作。

设时钟周期为：

T

主频为：

f

关系：

f = \frac{1}{T}

因此：

T = \frac{1}{f}

例如主频：

f = 2 GHz

意味着：

f = 2 \times 1 0^{9} Hz

所以一个时钟周期：

T = \frac{1}{2 \times 1 0 ^{9}} = 0.5 ns

二十一、CPI 是什么

CPI：

Cycles Per Instruction

即：

平均执行一条指令需要多少个时钟周期。

例如：

CPI = 2

并不是说每一条指令都严格执行 2 个周期，而通常表示：

对这个程序中的全部指令求平均，每条指令需要 2 个周期。

二十二、多种指令的平均 CPI 怎么算——必会

设各种指令占比为：

p_{1}, p_{2}, \dots, p_{n}

相应 CPI 为：

C P I_{1}, C P I_{2}, \dots, C P I_{n}

则：

C P I_{avg} = i = 1 \sum n p_{i} \cdot C P I_{i}

2013 年真题型

某 CPU 主频为：

1.2 GHz

指令比例：

指令	比例	CPI
A	50%	2
B	20%	3
C	10%	4
D	20%	5

先算平均 CPI：

C P I = 0.5 \times 2 + 0.2 \times 3 + 0.1 \times 4 + 0.2 \times 5

C P I = 3

这一类题的第一步永远是：

先做加权平均。

该真题正是以此继续计算 MIPS。

二十三、CPU 执行时间公式——全章核心

设程序包含指令数：

I C

平均 CPI：

C P I

主频：

f

则总时钟周期数为：

CPU 时钟周期数 = I C \times C P I

而：

T_{CPU} = 时钟周期数 \times 时钟周期

因此：

T_{CPU} = I C \times C P I \times T

又因为：

T = \frac{1}{f}

得到最重要公式：

T_{CPU} = \frac{I C \times C P I}{f}

二十四、为什么“主频高 = CPU 一定快”是错的

从：

T_{CPU} = \frac{I C \times C P I}{f}

可以立即看出来：

CPU 时间由三个因素决定。

因素	越怎样通常越快
指令条数 IC	越少
CPI	越小
主频	越高

所以即使：

CPU A：4GHz
CPU B：3GHz

也不能直接判断 A 更快。

假如：

C P I_{A} = 4

C P I_{B} = 2

即使指令数相同，B 也可能更快。

模拟题也专门把“CPU 时钟频率越高，计算机运行速度越快”作为错误表述。

二十五、性能比较题最简单的方法：直接做比值

假设同一个程序在两台同 ISA 机器上执行，因此指令条数相同。

则：

T_{1} = \frac{I C \times C P I _{1}}{f _{1}}

T_{2} = \frac{I C \times C P I _{2}}{f _{2}}

两式相除：

\frac{T _{1}}{T _{2}} = \frac{C P I _{1}}{C P I _{2}} \times \frac{f _{2}}{f _{1}}

这样 IC 直接消掉。

2017 真题型

M1：

f_{1} = 1.5 GHz

C P I_{1} = 2

M2：

f_{2} = 1.2 GHz

C P I_{2} = 1

则：

\frac{T _{1}}{T _{2}} = \frac{2}{1} \times \frac{1.2}{1.5}

= 1.6

即 M1 反而运行得更慢。

这就是：

主频高，并不意味着性能高。

该题是历年第一章非常典型的出题方式。

二十六、编译优化题怎么做

假设原来：

T = \frac{I C \times C P I}{f}

优化以后：

指令数减少
但 CPI 增大

不要凭感觉判断，直接列比例。

2014 真题

优化后指令数为原来的：

70%

平均 CPI 变成原来的：

1.2

主频不变。

所以：

\frac{T _{new}}{T _{old}} = 0.7 \times 1.2

= 0.84

原时间 20 秒：

T_{new} = 20 \times 0.84

= 16.8 s

答案就是 16.8 秒。

这里体现一个特别重要的思想：

优化一个因素可能恶化另一个因素，因此必须看最终 CPU 时间。

二十七、局部加速题——只加速 CPU 不等于整个程序同比加速

2012 真题非常典型。

程序总时间：

100 s

其中 CPU 时间：

90 s

I/O 时间：

10 s

CPU 速度提高 50%，即新 CPU 性能变为原来的：

1.5

所以新 CPU 时间：

T_{CPU, new} = \frac{90}{1.5}

= 60 s

I/O 没变化：

T_{IO} = 10 s

所以总时间：

T_{new} = 60 + 10 = 70 s

这体现了一个非常重要的计算机系统思想：

整体性能受没有被优化的部分限制。

后面学流水线、Cache、并行计算时还会反复遇到类似思想。

二十八、资料例题：主频提高为什么性能没有同比提高

资料给出的例子非常值得掌握。

M1：

f_{1} = 2 GHz

程序运行：

T_{1} = 10 s

则原程序总时钟周期数：

C_{1} = T_{1} f_{1}

= 10 \times 2 \times 1 0^{9}

= 2 \times 1 0^{10}

M2 的 CPI 是 M1 的 1.5 倍，所以所需时钟周期数：

C_{2} = 1.5 \times 2 \times 1 0^{10}

= 3 \times 1 0^{10}

若要求 6 秒完成：

f_{2} = \frac{3 \times 1 0 ^{10}}{6}

= 5 GHz

也就是说主频从：

2 GHz

提高到了：

5 GHz

增加 2.5 倍，但运行时间只是：

10s → 6s

性能提升约：

\frac{10}{6} \approx 1.67

倍，而不是 2.5 倍。

原因：

CPI 也发生了变化。

二十九、IPS 和 MIPS

IPS：

Instructions Per Second

表示每秒执行多少条指令。

由：

T_{instruction} = C P I \times T

可以推出：

I P S = \frac{f}{C P I}

资料给出的公式就是：

I P S = \frac{f}{C P I}

MIPS

MIPS：

Million Instructions Per Second

也就是每秒执行多少“百万条”指令。

M I P S = \frac{I C}{T _{CPU} \times 1 0 ^{6}}

结合 CPU 时间公式：

M I P S = \frac{f}{C P I \times 1 0 ^{6}}

刚才 2013 年真题继续算

已知：

f = 1.2 GHz = 1.2 \times 1 0^{9}

C P I = 3

则：

M I P S = \frac{1.2 \times 1 0 ^{9}}{3 \times 1 0 ^{6}}

= 400

所以答案是：

400 MIPS

三十、为什么 MIPS 不能随便比较不同 CPU

这是概念题常见坑。

假设机器 A：

1 条指令完成乘法

而机器 B：

需要 5 条指令完成同样的乘法

即使 B 每秒执行的“指令条数”更多：

MIPS 更大

也不一定代表 B 完成实际任务更快。

因为：

不同 ISA 中“一条指令能干多少事”并不一样。

所以资料明确指出：

MIPS 不适合直接比较不同 ISA 机器的真实计算性能。

三十一、FLOPS——科学计算常用

FLOPS：

Floating-point Operations Per Second

表示：

每秒完成多少次浮点运算。

注意它不是“指令数”，而是：

浮点操作次数。

资料给出的常见单位为：

1 MFLOPS = 1 0^{6} FLOPS

1 GFLOPS = 1 0^{9} FLOPS

1 TFLOPS = 1 0^{12} FLOPS

1 PFLOPS = 1 0^{15} FLOPS

1 EFLOPS = 1 0^{18} FLOPS

1 ZFLOPS = 1 0^{21} FLOPS

三十二、2021 真题为什么容易错

“神威·太湖之光”浮点性能：

93.0146 PFLOPS

因为：

1 P = 1 0^{15}

所以：

93.0146 PFLOPS = 93.0146 \times 1 0^{15}

也可以写为：

9.30146 \times 1 0^{16}

次浮点操作/秒。

这种题主要考前缀换算。

三十三、性能单位有一个极常见陷阱

存储容量里：

1 KiB = 2^{10} B

而性能、频率、速率里的：

1 GHz = 1 0^{9} Hz

1 GFLOPS = 1 0^{9} FLOPS

所以性能题中的 G、M、T、P 通常按十进制数量级处理。

资料也专门提醒了这一点。

三十四、2022 真题：平均 CPI + CPU 时间综合题

假设：

10000 条指令
80% CPI=1
20% CPI=10
主频 1GHz

先算平均 CPI：

C P I = 0.8 \times 1 + 0.2 \times 10

= 2.8

总周期数：

C = 10000 \times 2.8

= 28000

主频：

1 GHz = 1 0^{9} Hz

所以：

T = \frac{28000}{1 0 ^{9}}

= 28 \times 1 0^{- 6} s

即：

28 μ s

因此答案：

平均 CPI = 2.8
CPU 执行时间 = 28 μs

这道题几乎就是第一章性能计算的标准模板。

三十五、2023 真题：IPS + CPU 时间

假设：

f = 1.5 GHz

I C = 5 \times 1 0^{5}

C P I = 1.2

先算指令执行速度：

I P S = \frac{1.5 \times 1 0 ^{9}}{1.2}

= 1.25 \times 1 0^{9}

即：

1.25 GIPS

CPU 时间：

T = \frac{5 \times 1 0 ^{5} \times 1.2}{1.5 \times 1 0 ^{9}}

= 4 \times 1 0^{- 4} s

即：

0.4 ms

答案：

1.25 GIPS
0.4 ms

三十六、第一章性能题统一解题模板

看到任何性能计算题，不要一上来乱套 MIPS。

先画这一条关系链：

指令条数 IC
       ×
平均 CPI
       ↓
总时钟周期数
       ÷
主频
       ↓
CPU 执行时间

也就是：

I C \times C P I 时钟周期数 \div f T_{CPU}

因此最核心的三式只有：

C_{total} = I C \times C P I

T_{CPU} = \frac{C _{total}}{f}

T_{CPU} = \frac{I C \times C P I}{f}

其他 IPS、MIPS 等，基本都可以从这三式推出来。

三十七、性能提高多少倍怎么判断

若 A 的运行时间为：

T_{A}

B 为：

T_{B}

若 B 比 A 快，则 B 相对于 A 的加速比为：

S = \frac{T _{A}}{T _{B}}

例如：

A：10s
B：5s

则：

S = \frac{10}{5} = 2

说明 B 的性能是 A 的 2 倍。

这里一定注意：

性能与执行时间成反比。

因此：

Performance \propto \frac{1}{T}

不是时间越长性能越大。

三十八、基准程序是什么

只比较：

主频
CPI
MIPS

都可能片面。

所以真实系统往往使用“基准程序”进行性能测试。

所谓 benchmark：

用一组具有代表性的程序真正运行，比较所需时间或吞吐性能。

资料指出，基准程序能综合反映：

CPU
存储器
编译器
操作系统

等因素，比只看 MIPS 更有意义，但它也只能代表相应工作负载。

因此：

某 CPU 在一个 benchmark 中胜出，并不必然意味着它在所有程序中都更快。

三十九、第一章最容易错的几个概念

下面这些建议直接当判断题来记。

说法	判断	原因
CPU 能直接执行汇编语言	错	只能直接执行机器指令
指令和数据在内存中的二进制形式不同	错	形式上没有本质区别
冯·诺依曼机按内容访问存储器	错	通常按地址访问
经典冯·诺依曼机指令和数据存储器必须分开	错	经典结构共享存储系统
主频越高，CPU 一定越快	错	还取决于 IC 和 CPI
CPI 越小，机器一定越快	错	还要看主频和指令条数
MIPS 越高，任何机器都一定更快	错	ISA 不同不可简单比较
编译器把汇编语言变成机器语言	错	这是汇编器
解释程序会先生成完整目标程序再运行	错	通常逐句翻译执行
`.o` 文件通常已经是最终完整可执行程序	错	一般仍需链接
链接发生在汇编之前	错	顺序是预处理→编译→汇编→链接
FLOPS 衡量浮点运算能力	对	科学计算常用
PC 保存下一条将执行指令的地址	对	程序自动执行的核心机制

这些陷阱与历年真题和模拟题高度一致。

四十、这一章到底应该背到什么程度

按 408 的实际复习价值，建议分三个等级。

重要度	内容	要求
★★★★★	CPU 执行时间、CPI、主频、MIPS	必须熟练计算
★★★★★	存储程序、指令执行、PC	必须真正理解
★★★★★	编译→汇编→链接	必须能判断全过程
★★★★☆	机器语言、汇编语言、高级语言	高频选择题
★★★★☆	ISA 与微体系结构	理解软硬件接口
★★★☆☆	CPU、主存、I/O、总线功能	建立全书框架
★★☆☆☆	系统软件、应用软件	会辨析即可
★☆☆☆☆	四代计算机、发展史	识记基本对应关系即可

四十一、最后把第一章压缩成一张“脑图”

你以后做题时，可以在脑中快速展开成：

              计算机系统
           ┌──────┴──────┐
         硬件             软件
          │                │
   CPU 主存 I/O 总线   系统软件 应用软件
          │
          │
      冯·诺依曼思想
          │
      存储程序
          │
   程序和数据先入主存
          │
        PC 给地址
          │
   取指 → 译码 → 执行
          │
          ▼
     机器语言指令
          ▲
          │
高级语言 → 预处理 → 编译 → 汇编 → 链接
          │
          ▼
         ISA
   软件与硬件的接口

性能：
IC × CPI = 总周期数

总周期数 ÷ 主频 = CPU 时间

所以：

T_{CPU} = \frac{I C \times C P I}{f}

以及：

I P S = \frac{f}{C P I}

M I P S = \frac{f}{C P I \times 1 0 ^{6}}

再记住一句：

比较 CPU 性能，永远不要只盯着主频。

第一章做到这里，真正需要掌握的主干就完整了。后面学习 数据表示、存储器、指令系统、CPU、总线与 I/O 时，本章的“指令—数据—CPU—主存—性能”这条线会不断被补充细节。

第 1 章 计算机系统概述

On this page

第 1 章计算机系统概述