计算机工作过程和性能指标

理解计算机如何工作，就像理解汽车发动机如何运转一样重要。只有知道了内部机制，才能真正掌握如何优化性能、诊断问题。

程序存储原理：计算机革命的起点

冯·诺依曼的天才创新

1945年，数学家冯·诺依曼提出了一个看似简单，却改变世界的想法：

程序存储原理 (Stored Program Concept)

将程序指令和数据都以二进制形式存储在同一个存储器中，计算机按照程序指令的顺序自动执行。

这个概念的革命性在于：程序不再是硬件电路，而是可以像数据一样被存储、修改和传输的软件！

革命性在哪里？

在程序存储之前：

• 计算机是专用机器，一个任务一台机器
• 改变功能需要重新接线（如ENIAC需要几周时间重新布线）
• 程序员实际上是”接线员”

程序存储之后：

• 一台计算机可以执行任何程序
• 改变功能只需加载不同的程序
• 计算机变成了真正的”通用机器”

程序在内存中的样子

内存地址    内容              说明
0x1000:    10110001         指令：LOAD R1, [0x2000]
0x1004:    10110010         指令：LOAD R2, [0x2004]
0x1008:    00000011         指令：ADD R3, R1, R2
0x100C:    11000011         指令：STORE R3, [0x2008]
...
0x2000:    00000101         数据：5
0x2004:    00000011         数据：3
0x2008:    00000000         数据：结果位置（将存储8）

关键点：CPU无法区分某个二进制数是指令还是数据，完全取决于如何使用它！

为什么说'程序和数据在本质上是相同的'？这有什么实际意义？

本质相同的原因：

1. 都以二进制形式存储
2. 都占用内存空间
3. 都可以被读取和修改
4. CPU无法从形式上区分它们

实际意义：

正面应用：

• 编译器：读取源代码（数据），生成可执行程序（程序）
• JIT编译：运行时将代码（数据）编译成机器码（程序）
• 动态加载：程序运行时加载插件（数据变程序）
• 自修改代码：程序修改自己的指令

安全隐患：

• 病毒：伪装成数据文件，执行后变成恶意程序
• 缓冲区溢出：数据覆盖程序代码，执行恶意指令
• 代码注入：将恶意代码注入到数据区，然后执行

这就是为什么现代操作系统要区分”可执行”和”不可执行”内存区域！

指令执行过程：计算机的”心跳”

计算机执行程序，就像人的心脏跳动一样，是一个周而复始的过程。

指令周期的五个阶段

指令周期 (Instruction Cycle)

CPU执行一条指令所经历的完整过程，通常分为五个阶段：取指(IF)、译码(ID)、执行(EX)、访存(MEM)、写回(WB)。

这个周期不断重复，直到程序结束。

┌─────────┐    ┌─────────┐    ┌─────────┐    ┌─────────┐    ┌─────────┐
│  取指   │ -> │  译码   │ -> │  执行   │ -> │  访存   │ -> │  写回   │
│  (IF)   │    │  (ID)   │    │  (EX)   │    │ (MEM)   │    │  (WB)   │
└─────────┘    └─────────┘    └─────────┘    └─────────┘    └─────────┘
     ↑                                                              │
     └──────────────────────────────────────────────────────────────┘
                        循环执行下一条指令

阶段1：取指 (Instruction Fetch, IF)

目标：从内存中取出下一条要执行的指令

详细步骤：

1. 程序计数器(PC)存储着下一条指令的地址
2. 将PC的值发送到地址总线
3. 内存根据地址返回指令
4. 指令通过数据总线传送到CPU
5. 指令存入指令寄存器(IR)
6. PC自动加1（或加指令长度），指向下一条指令

时间：通常需要1-2个时钟周期

阶段2：译码 (Instruction Decode, ID)

目标：分析指令的含义，准备执行所需的资源

详细步骤：

1. 指令译码器分析IR中的操作码
2. 确定指令类型（算术、逻辑、访存、跳转等）
3. 识别操作数的位置（寄存器、内存、立即数）
4. 读取寄存器中的操作数
5. 计算内存地址（如果需要）
6. 准备控制信号

时间：通常需要1个时钟周期

阶段3：执行 (Execute, EX)

目标：执行指令规定的操作

详细步骤：

• 算术指令：ALU执行加减乘除
• 逻辑指令：ALU执行与或非异或
• 移位指令：移位器执行左移右移
• 跳转指令：计算跳转目标地址
• 访存指令：计算内存地址

时间：1-多个时钟周期（取决于操作复杂度）

阶段4：访存 (Memory Access, MEM)

目标：访问数据存储器（如果需要）

详细步骤：

• LOAD指令：从内存读取数据
• STORE指令：将数据写入内存
• 其他指令：跳过此阶段

时间：如果命中Cache，1-2个周期；如果访问主存，10-100个周期

阶段5：写回 (Write Back, WB)

目标：将结果写回目标位置

详细步骤：

1. 将运算结果写入目标寄存器
2. 更新状态标志（零标志、进位标志、溢出标志等）
3. 准备执行下一条指令

时间：通常1个时钟周期

具体例子：ADD指令

指令：ADD R3, R1, R2（R3 = R1 + R2）

IF:  从内存地址0x1000取出指令 "ADD R3, R1, R2"
     PC: 0x1000 -> 0x1004

ID:  译码：操作是ADD，源操作数R1和R2，目标R3
     读取R1的值（假设是5）
     读取R2的值（假设是3）

EX:  ALU执行加法：5 + 3 = 8

MEM: 此指令不需要访存，跳过

WB:  将结果8写入R3
     更新状态标志（如果结果为0，设置零标志）

总时间：5个时钟周期（如果没有流水线）

具体例子：LOAD指令

指令：LOAD R1, [R2+100]（从内存地址R2+100读取数据到R1）

IF:  从内存取出指令 "LOAD R1, [R2+100]"
     PC自动加1

ID:  译码：操作是LOAD，源是内存[R2+100]，目标是R1
     读取R2的值（假设是0x2000）

EX:  计算内存地址：0x2000 + 100 = 0x2064

MEM: 从内存地址0x2064读取数据（假设是42）

WB:  将数据42写入R1

为什么不同指令的执行时间不同？这对性能有什么影响？

执行时间不同的原因：

1. 访存指令慢：

   • 需要访问内存（MEM阶段）
   • 如果Cache未命中，可能需要几十到上百个周期

2. 复杂运算慢：

   • 乘法比加法慢（需要多个周期）
   • 除法更慢（可能需要几十个周期）
   • 浮点运算通常比整数运算慢

3. 跳转指令影响流水线：

   • 如果跳转预测错误，需要清空流水线
   • 损失多个周期

对性能的影响：

1. CPI不是常数：

   • 不同程序的CPI不同
   • 访存密集型程序CPI高
   • 计算密集型程序CPI可能较低

2. 优化方向：

   • 减少访存（使用寄存器）
   • 避免复杂运算（用移位代替乘法）
   • 减少分支（减少跳转）

3. 编译器优化：

   • 指令调度：重排指令减少等待
   • 循环展开：减少跳转次数
   • 寄存器分配：减少访存

这就是为什么同样的算法，优化后可以快几倍甚至几十倍！

计算机性能指标：如何科学地衡量”快慢”

“这台电脑快不快？“——这个问题看似简单，实则复杂。我们需要多个指标来全面衡量性能。

性能指标体系

性能指标
├── 速度指标
│   ├── 主频 (Clock Frequency)
│   ├── CPI (Cycles Per Instruction)
│   ├── IPC (Instructions Per Cycle)
│   └── MIPS (Million Instructions Per Second)
├── 时间指标
│   ├── CPU时间
│   ├── 响应时间
│   └── 吞吐量
└── 效率指标
    ├── 能效比
    ├── 性价比
    └── Amdahl定律

1. 主频（Clock Frequency）

主频 / 时钟频率

CPU内部时钟信号的频率，表示CPU每秒钟振荡的次数。单位是赫兹(Hz)。

1 GHz = 10^9 Hz = 每秒10亿次振荡

主频与时钟周期的关系

$$\text{主频} = \frac{1}{\text{时钟周期}}$$

例如：时钟周期 = 0.2 纳秒，则主频 = 1 / (0.2 × 10^-9) = 5 GHz

真实例子：

• Intel Core i9-13900K：基础频率3.0GHz，最高5.8GHz
• AMD Ryzen 9 7950X：基础频率4.5GHz，最高5.7GHz
• Apple M2：最高3.5GHz（但能效极高）

2. CPI（Cycles Per Instruction）

CPI - 每条指令的时钟周期数

执行一条指令平均需要多少个时钟周期。CPI越小，CPU效率越高。

CPI计算公式

$$\text{CPI} = \frac{\text{总时钟周期数}}{\text{指令总数}}$$

对于混合指令类型：

$$\text{平均CPI} = \sum_{i=1}^{n} (\text{CPI}_i \times \text{指令}_i\text{占比})$$

例子：假设一个程序有：

• 50%的指令CPI=1（简单算术）
• 30%的指令CPI=2（访存）
• 20%的指令CPI=5（乘法）

平均CPI = 0.5×1 + 0.3×2 + 0.2×5 = 0.5 + 0.6 + 1.0 = 2.1

典型CPI值：

• 简单RISC处理器：CPI ≈ 1-2
• 复杂CISC处理器：CPI ≈ 2-4
• 超标量处理器：CPI < 1（IPC > 1，每周期执行多条指令）

3. CPU执行时间

这是最重要的性能指标！

CPU时间基本公式

$$\text{CPU时间} = \text{指令数} \times \text{CPI} \times \text{时钟周期}$$

或者：

$$\text{CPU时间} = \frac{\text{指令数} \times \text{CPI}}{\text{主频}}$$

计算例子：

程序A：

• 指令数：1,000,000条
• CPI：2
• 主频：2GHz

CPU时间 = (1,000,000 × 2) / (2 × 10^9) = 0.001秒 = 1毫秒

程序B（优化后）：

• 指令数：800,000条（减少20%）
• CPI：2.5（稍微增加）
• 主频：2GHz

CPU时间 = (800,000 × 2.5) / (2 × 10^9) = 0.001秒 = 1毫秒

结论：虽然CPI增加了，但因为指令数减少，总时间不变！

4. MIPS（Million Instructions Per Second）

MIPS计算公式

$$\text{MIPS} = \frac{\text{指令数}}{\text{执行时间} \times 10^6}$$

或者：

$$\text{MIPS} = \frac{\text{主频}}{\text{CPI} \times 10^6}$$

例子：

• 主频：3GHz
• CPI：2

MIPS = 3000 / 2 = 1500 MIPS

为什么MIPS可能误导人？

1. 不同指令复杂度不同：

   • 简单加法和复杂除法都算1条指令
   • MIPS高不代表实际工作快

2. 不同程序MIPS不同：

   • 同一CPU，运行不同程序，MIPS可能差很多

3. 编译器影响：

   • 优化后指令数减少，MIPS降低，但实际更快！

5. 吞吐量 vs 响应时间

吞吐量 (Throughput)

单位时间内完成的任务数量。衡量系统的整体处理能力。

单位：任务/秒、事务/秒、请求/秒

响应时间 (Response Time)

完成一个任务所需的时间。衡量单个任务的快慢。

单位：秒、毫秒、微秒

关系：

• 吞吐量 ≈ 1 / 平均响应时间
• 但不完全相等（有排队、并发等因素）

例子：餐厅

高吞吐量：

• 快餐店：每小时服务100位客人
• 但每位客人可能要排队等5分钟

低响应时间：

• 高级餐厅：客人一到就有服务
• 但每小时只能服务20位客人

计算机中的权衡：

• 服务器：追求高吞吐量（处理更多请求）
• 个人电脑：追求低响应时间（快速响应用户）

6. Amdahl定律：并行加速的极限

Amdahl定律

描述了并行化对程序加速的理论上限。由Gene Amdahl在1967年提出。

核心思想：程序的加速比受限于不能并行化的部分。

Amdahl定律公式

$$\text{加速比} = \frac{1}{(1-P) + \frac{P}{N}}$$

其中：

• P = 可并行化部分的比例（0到1之间）
• N = 处理器数量
• (1-P) = 串行部分的比例

例子1：程序90%可并行

使用4个处理器：

$$\text{加速比} = \frac{1}{0.1 + \frac{0.9}{4}} = \frac{1}{0.1 + 0.225} = \frac{1}{0.325} \approx 3.08$$

使用无限个处理器：

$$\text{加速比} = \frac{1}{0.1 + 0} = 10$$

结论：即使有无限个处理器，最多只能快10倍！

例子2：程序50%可并行

使用无限个处理器：

$$\text{加速比} = \frac{1}{0.5} = 2$$

结论：最多只能快2倍！

为什么不能通过增加处理器数量获得无限加速？

Amdahl定律告诉我们的残酷现实：

1. 串行部分是瓶颈：

   • 无论有多少处理器，串行部分还是要一个一个执行
   • 就像高速公路再宽，收费站只有一个

2. 实际加速比更低：

   • 通信开销：处理器间通信需要时间
   • 负载不均：有的处理器忙，有的闲
   • 同步开销：等待其他处理器完成

3. 优化策略：

   • 首先优化串行部分：减少(1-P)
   • 然后并行化：增加P
   • 最后增加处理器：增加N

现实例子：

• 视频渲染：95%可并行，加速效果好
• 数据库事务：30%可并行，加速效果有限
• 编译代码：70%可并行，中等加速

这就是为什么不是所有程序都适合多核处理器！

真实CPU性能对比

Intel Core i9-13900K vs AMD Ryzen 9 7950X

指标	Intel i9-13900K	AMD Ryzen 9 7950X
核心数	24核（8P+16E）	16核
线程数	32	32
基础频率	3.0 GHz	4.5 GHz
最高频率	5.8 GHz	5.7 GHz
缓存	L2 32MB + L3 36MB	L2 16MB + L3 64MB
TDP	125W (基础) / 253W (最高)	170W
制程	Intel 7 (10nm)	TSMC 5nm

性能对比（Cinebench R23）：

• 单核：i9-13900K ≈ 2200分，7950X ≈ 2000分
• 多核：i9-13900K ≈ 40000分，7950X ≈ 38000分

结论：性能接近，各有优势

• Intel：单核稍强，游戏性能好
• AMD：能效更好，多核持续性能强

练习题

基础练习（1-4题）

练习 1

简述指令执行的五个阶段，并说明每个阶段的主要任务。

参考答案

指令执行的五个阶段：

1. 取指 (IF - Instruction Fetch)：

   • 从内存中取出指令
   • 根据PC（程序计数器）的值读取指令
   • 将指令存入IR（指令寄存器）
   • PC自动加1，指向下一条指令

2. 译码 (ID - Instruction Decode)：

   • 分析指令的操作码
   • 确定指令类型和操作数位置
   • 读取寄存器中的操作数
   • 准备执行所需的控制信号

3. 执行 (EX - Execute)：

   • ALU执行算术或逻辑运算
   • 计算内存地址（访存指令）
   • 计算跳转目标地址（跳转指令）

4. 访存 (MEM - Memory Access)：

   • LOAD指令：从内存读取数据
   • STORE指令：将数据写入内存
   • 其他指令：跳过此阶段

5. 写回 (WB - Write Back)：

   • 将运算结果写回目标寄存器
   • 更新状态标志（零标志、进位标志等）
   • 准备执行下一条指令

这五个阶段构成一个完整的指令周期，不断循环执行。

练习 2

已知某CPU的时钟周期为0.25纳秒，求其主频是多少GHz？

参考答案

解：

根据公式：主频 = 1 / 时钟周期

$$\text{主频} = \frac{1}{0.25 \times 10^{-9}} = \frac{1}{0.25} \times 10^9 = 4 \times 10^9 \text{ Hz} = 4 \text{ GHz}$$

答案：4 GHz

练习 3

某程序包含以下指令：

• 40%的指令CPI=1
• 30%的指令CPI=2
• 30%的指令CPI=4

求该程序的平均CPI。

参考答案

解：

使用加权平均公式：

$$\text{平均CPI} = \sum (\text{CPI}_i \times \text{比例}_i)$$$$\text{平均CPI} = 1 \times 0.4 + 2 \times 0.3 + 4 \times 0.3$$$$= 0.4 + 0.6 + 1.2 = 2.2$$

答案：平均CPI = 2.2

解释：这意味着平均每条指令需要2.2个时钟周期。

练习 4

某程序包含100万条指令，平均CPI为2.5，CPU主频为2GHz。求CPU执行时间。

参考答案

解：

使用CPU时间公式：

$$\text{CPU时间} = \frac{\text{指令数} \times \text{CPI}}{\text{主频}}$$$$\text{CPU时间} = \frac{1,000,000 \times 2.5}{2 \times 10^9}$$$$= \frac{2,500,000}{2,000,000,000} = 0.00125 \text{ 秒} = 1.25 \text{ 毫秒}$$

答案：CPU执行时间 = 1.25毫秒

验证：

• 总周期数 = 1,000,000 × 2.5 = 2,500,000个周期
• 每个周期时间 = 1 / (2×10^9) = 0.5纳秒
• 总时间 = 2,500,000 × 0.5纳秒 = 1.25毫秒 ✓

中级练习（5-6题）

练习 5

比较两个CPU的性能：

CPU A：

• 主频：3GHz
• CPI：2
• 执行程序需要1000万条指令

CPU B：

• 主频：4GHz
• CPI：3
• 执行同一程序需要800万条指令（编译器优化更好）

哪个CPU执行这个程序更快？快多少？

参考答案

解：

CPU A的执行时间：

$$\text{时间}_A = \frac{10,000,000 \times 2}{3 \times 10^9} = \frac{20,000,000}{3,000,000,000} = 0.00667 \text{ 秒} \approx 6.67 \text{ 毫秒}$$

CPU B的执行时间：

$$\text{时间}_B = \frac{8,000,000 \times 3}{4 \times 10^9} = \frac{24,000,000}{4,000,000,000} = 0.006 \text{ 秒} = 6 \text{ 毫秒}$$

加速比：

$$\text{加速比} = \frac{\text{时间}_A}{\text{时间}_B} = \frac{6.67}{6} \approx 1.11$$

答案：CPU B更快，快约11%（或快0.67毫秒）

分析：

• CPU B虽然CPI更高（效率更低），但主频更高且指令数更少
• 编译器优化减少了20%的指令，这是关键因素
• 这说明：性能不只看硬件，软件优化同样重要！

练习 6

某程序60%的代码可以并行化。如果使用4个处理器，根据Amdahl定律，理论加速比是多少？如果使用16个处理器呢？

参考答案

解：

Amdahl定律公式：

$$\text{加速比} = \frac{1}{(1-P) + \frac{P}{N}}$$

其中 P = 0.6（可并行部分），1-P = 0.4（串行部分）

使用4个处理器：

$$\text{加速比}_4 = \frac{1}{0.4 + \frac{0.6}{4}} = \frac{1}{0.4 + 0.15} = \frac{1}{0.55} \approx 1.82$$

使用16个处理器：

$$\text{加速比}_{16} = \frac{1}{0.4 + \frac{0.6}{16}} = \frac{1}{0.4 + 0.0375} = \frac{1}{0.4375} \approx 2.29$$

理论极限（无限个处理器）：

$$\text{加速比}_{\infty} = \frac{1}{0.4} = 2.5$$

答案：

• 4个处理器：加速约1.82倍
• 16个处理器：加速约2.29倍
• 理论极限：2.5倍

分析：

• 从4核到16核，只增加了0.47倍的加速
• 40%的串行部分限制了加速比
• 即使有无限个处理器，最多也只能快2.5倍
• 这就是为什么要优化串行部分！

高级练习（7-8题）

练习 7

某程序原始性能：

• 执行时间：10秒
• 其中访存操作占60%的时间（6秒）
• 计算操作占40%的时间（4秒）

现在有两种优化方案：

• 方案A：优化访存，使访存时间减少50%
• 方案B：优化计算，使计算时间减少70%

哪个方案效果更好？为什么？

参考答案

解：

方案A（优化访存）：

• 访存时间：6秒 × 50% = 3秒（节省3秒）
• 计算时间：4秒（不变）
• 总时间：3 + 4 = 7秒
• 加速比：10 / 7 ≈ 1.43

方案B（优化计算）：

• 访存时间：6秒（不变）
• 计算时间：4秒 × 30% = 1.2秒（节省2.8秒）
• 总时间：6 + 1.2 = 7.2秒
• 加速比：10 / 7.2 ≈ 1.39

答案：方案A效果更好（快0.2秒）

深层分析：

这是Amdahl定律的实际应用：

方案A：

$$\text{加速比} = \frac{1}{0.4 + \frac{0.6}{2}} = \frac{1}{0.7} \approx 1.43$$

方案B：

$$\text{加速比} = \frac{1}{0.6 + \frac{0.4}{3.33}} = \frac{1}{0.72} \approx 1.39$$

结论：

• 优化占比大的部分（访存60%）效果更好
• 即使优化幅度小（50% vs 70%），但因为基数大，总体效果好
• Make the common case fast!（优化常见情况）

这就是性能优化的黄金法则！

练习 8

你要为公司购买服务器，有两个选择：

服务器A：

• CPU：Intel Xeon，主频3.5GHz，16核
• 内存：64GB DDR4-3200
• 价格：$3000
• 单核性能强，适合单线程任务

服务器B：

• CPU：AMD EPYC，主频2.8GHz，32核
• 内存：128GB DDR4-3200
• 价格：$4000
• 多核性能强，适合并行任务

公司的主要工作负载：

• 70%是Web服务（高并发，可并行）
• 30%是数据库查询（部分可并行）

你会选择哪个？请说明理由。

参考答案

分析：

工作负载特征：

• Web服务（70%）：高并发，可充分利用多核
• 数据库查询（30%）：部分可并行，但也需要单核性能

服务器A的优势：

• 单核性能强（3.5GHz）
• 价格便宜$1000
• 适合单线程任务

服务器B的优势：

• 核心数多（32核 vs 16核）
• 内存大（128GB vs 64GB）
• 适合高并发场景

性能估算：

Web服务性能（假设可完全并行）：

• 服务器A：16核 × 3.5GHz = 56 GHz·核
• 服务器B：32核 × 2.8GHz = 89.6 GHz·核
• 服务器B快约60%

数据库性能（假设50%可并行）： 根据Amdahl定律，多核优势会打折扣，但服务器B仍有优势

推荐：选择服务器B

理由：

1. 工作负载匹配：70%是高并发Web服务，充分利用32核
2. 内存优势：128GB内存对Web服务和数据库都重要
3. 未来扩展：业务增长时，多核和大内存更有价值
4. 性价比：虽然贵$1000，但性能提升超过33%

但如果：

• 预算紧张：选A
• 主要是单线程任务：选A
• 需要最高单核性能：选A

结论：没有绝对的”最好”，要根据实际需求选择！

---

总结

核心公式速查

公式	说明
$\text{主频} = \frac{1}{\text{时钟周期}}$	主频与时钟周期的关系
$\text{CPI} = \frac{\text{总周期数}}{\text{指令数}}$	平均每条指令的周期数
$\text{CPU时间} = \frac{\text{指令数} \times \text{CPI}}{\text{主频}}$	性能基本方程
$\text{MIPS} = \frac{\text{主频}}{\text{CPI} \times 10^6}$	每秒百万条指令
$\text{加速比} = \frac{1}{(1-P) + \frac{P}{N}}$	Amdahl定律

中英对照

中文术语	英文术语	缩写	说明
程序存储原理	Stored Program Concept	-	冯·诺依曼的核心思想
指令周期	Instruction Cycle	-	执行一条指令的完整过程
取指	Instruction Fetch	IF	从内存取指令
译码	Instruction Decode	ID	分析指令含义
执行	Execute	EX	执行运算
访存	Memory Access	MEM	访问数据存储器
写回	Write Back	WB	写回结果
主频	Clock Frequency	-	时钟频率
每指令周期数	Cycles Per Instruction	CPI	执行效率指标
每秒百万条指令	Million Instructions Per Second	MIPS	处理能力指标
吞吐量	Throughput	-	单位时间处理任务数
响应时间	Response Time	-	完成任务所需时间
阿姆达尔定律	Amdahl’s Law	-	并行加速上限

上一章节 计算机系统基本组成 学习计算机系统的基本组成和层次结构 下一章节 综合练习题 计算机系统概述综合练习题，涵盖基础、中级、高级三个难度