Ch13 §02 计算机架构 · 讲解稿¶

章节定位: Ch13 硬件基础。教"程序如何在硬件上跑": 冯诺依曼架构 / CPU / 缓存层级 / GPU。承接: §01 离散数学 (算法复杂度) → §02 真实硬件走向: §03 OS (管理硬件) / §04 并发 (用上多核) 篇幅: ~4200 字 / 阅读 12 分钟 / 讲解 25-30 分钟

一 · 一句话总览¶

计算机架构 = 程序从指令到执行的全链路: 冯诺依曼 (CPU + 内存 + 总线 + IO) → CPU 内部 (IC/CPI/流水线) → 缓存层级 → GPU 并行。AI 工程师需理解此节, 才能优化代码。

二 · 心智模型¶

把计算机想象成"工厂":

组件	工厂对应
CPU	加工车间
内存	仓库
缓存	临时货架
总线	传送带
IO	出入口

CPU 快, 内存慢 — 瓶颈在传送带。这是"内存墙"。

三 · 章节主线 (5 段)¶

第 1 段 · 冯诺依曼架构 (8 分钟)¶

3.1.1 五部分¶

        输入  ──┐          ┌── 输出
                 ↓          ↑
                ┌────────────┐
                │   CPU      │
                │ ┌───┐┌───┐ │
                │ │ALU││CU │ │
                │ └───┘└───┘ │
                └─────┬──────┘
                      ↓↑
                ┌────────────┐
                │   内存     │
                │  (RAM)    │
                └─────┬──────┘
                      ↓↑
                ┌────────────┐
                │   总线     │
                └────────────┘

部件	功能
CPU (ALU + CU)	计算 + 控制
内存	存指令和数据
总线	数据 / 地址 / 控制
输入	键盘 / 鼠标 / 网络
输出	显示器 / 磁盘

3.1.2 存储程序 (Stored-Program)¶

程序 = 数据, 都在内存中。CPU 取出指令执行, 改写内存。

3.1.3 改进: Harvard 架构¶

指令 / 数据分两条总线 (DSP 用), 更快但贵。

第 2 段 · CPU 性能公式与流水线 (10 分钟)¶

3.2.1 三因子公式¶

\[T_{\text{CPU}} = IC \times CPI \times T_{\text{cycle}}\]

因子	含义	优化
IC	指令数 (Instruction Count)	编译优化, RISC
CPI	每指令周期 (Cycles Per Instruction)	流水线, 并行
\(T_{\text{cycle}}\)	周期时间	工艺 (制程)

3.2.2 优化三因子¶

减 IC: 用 SIMD / 向量化 (e.g., AVX)
减 CPI: 流水线, 多发射, 分支预测
减 \(T_{\text{cycle}}\): 7nm → 5nm → 3nm

3.2.3 流水线¶

把指令分成 5 段: 取指 IF → 译码 ID → 执行 EX → 访存 MEM → 写回 WB。

理论 CPI = 1 (每周期完成一条指令)。但: - 数据冒险 (RAW) - 控制冒险 (分支) - 结构冒险 (资源冲突)

3.2.4 分支预测¶

预测 if-else 走哪边。预测失败 ~10-20 周期惩罚。

深度学习分支少 → 容易预测。控制流多的代码 (e.g., Python loop) 难预测。

3.2.5 实测¶

import time
n = 100_000_000

# 简单循环
t0 = time.perf_counter()
s = 0
for i in range(n):
    s += i
t1 = time.perf_counter()
print(f"Loop: {t1-t0:.4f}s")  # ~3s

# NumPy 向量化
import numpy as np
t0 = time.perf_counter()
arr = np.arange(n)
s = arr.sum()
t1 = time.perf_counter()
print(f"NumPy: {t1-t0:.4f}s")  # ~0.1s, 30× 加速

第 3 段 · 内存层级 (10 分钟)¶

3.3.1 层级¶

层级	大小	延迟	带宽
寄存器	KB	< 1 ns	TB/s
L1	64 KB	1 ns	TB/s
L2	256 KB-1 MB	10 ns	100 GB/s
L3	8-32 MB	30 ns	50 GB/s
DRAM	16-128 GB	100 ns	50 GB/s
SSD	TB	100 μs	5 GB/s
HDD	TB	10 ms	200 MB/s

3.3.2 局部性原理¶

时间局部性: 最近访问的, 很可能再访问
空间局部性: 附近的地址, 很可能再访问

代码优化: 顺序访问数组 (缓存友好), 避免随机访问。

3.3.3 平均访问时间¶

\[T_{\text{avg}} = h \cdot T_{\text{L1}} + (1-h)(T_{\text{L1}} + T_{\text{L2}})\]

\(h = 0.95, T_{\text{L1}} = 1, T_{\text{L2}} = 10\) → \(T_{\text{avg}} = 1.45\) ns。

3.3.4 Cache line¶

典型 64 字节。一次取一整行。遍历数组步长 1 → 命中率高; 步长 64 → 浪费。

# Cache 友好
arr = np.zeros((1000, 1000), order='C')  # 行优先
for i in range(1000):
    for j in range(1000):
        s += arr[i, j]  # 顺序访问 ✓

# Cache 不友好 (Fortran 风格)
arr_f = np.zeros((1000, 1000), order='F')  # 列优先
for i in range(1000):
    for j in range(1000):
        s += arr_f[j, i]  # 跳行 ✗

第 4 段 · GPU 与并行架构 (8 分钟)¶

3.4.1 GPU vs CPU¶

维度	CPU	GPU
核心数	8-64	数千
频率	3-5 GHz	1-2 GHz
缓存	大	小
擅长	控制流 / 串行	数据并行

3.4.2 SIMT¶

Single Instruction Multiple Threads。同一 warp (32 线程) 跑同一指令, 不同数据。

3.4.3 GPU 内存层级¶

层级	大小	速度
Register	KB / thread	极快
Shared	48 KB / block	快
L1/L2	MB	中
Global (HBM)	80 GB (H100)	慢

3.4.4 GPU FLOPS¶

\[\text{FLOPs} = N_{\text{SM}} \times \text{cores/SM} \times F \times 2\]

H100: 132 SM × 128 FP16 cores × 1.8 GHz × 2 = ~990 TFLOPS。

A100: 312 TFLOPS (FP16)。

3.4.5 内存墙对 AI¶

LLM 推理 memory-bound: 加载权重 70 GB, GPU 带宽 3 TB/s → 至少 23 ms 才加载完。KV cache 进一步增加负担。

解决: 量化 (INT8/INT4), KV cache 压缩, PagedAttention (vLLM)。

第 5 段 · 实践: Profiling 工具 (8 分钟)¶

3.5.1 CPU profiling¶

# perf (Linux)
perf stat python my_program.py
perf record -g python my_program.py
perf report

# py-spy (Python)
pip install py-spy
py-spy top --pid <pid>

3.5.2 GPU profiling¶

# nsys (NVIDIA Nsight Systems)
nsys profile -o my_profile python train.py
nsys-ui my_profile.nsys-rep  # 可视化

# ncu (Nsight Compute, kernel 级)
ncu --set full python train.py

# PyTorch Profiler
with torch.profiler.profile(
    activities=[torch.profiler.ProfilerActivity.CPU, torch.profiler.ProfilerActivity.CUDA],
    record_shapes=True
) as prof:
    model(input)
print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=10))

3.5.3 内存分析¶

import torch
print(f"Allocated: {torch.cuda.memory_allocated()/1e9:.2f} GB")
print(f"Cached: {torch.cuda.memory_reserved()/1e9:.2f} GB")

# 详细追踪
torch.cuda.memory_summary()

四 · 易错点 (5 条)¶

CPU 性能公式: \(T = IC \cdot CPI \cdot T_{\text{cycle}}\), 三个独立因子, 不要混。
流水线 CPI: 实际 CPI > 1 (因冒险), 理想 CPI = 1。
缓存大小: L1 是 KB, 不是 GB; DRAM 是 GB。
GPU 内存: HBM 是高带宽内存, 但比 CPU DRAM 还慢。
内存墙: 即使 GPU 算力强, 内存带宽限制性能。

五 · 跨章连接¶

章节	关联
Ch03 §05 梯度	GPU 加速
Ch07 §04 Transformer	LLM 推理 GPU
Ch08 §03 CNN	cuDNN
Ch11 §05 VLA	边缘 GPU
Ch12 §05 EGNN	GPU 分子动力学

六 · 自测 5 题¶

CPU 时间公式? 三个因子?
内存层级从快到慢?
CPU vs GPU 核心差异?
内存墙 (Memory Wall) 是什么?
SIMT 的含义?

七 · 一句话总结¶

计算机架构 = 程序从指令到执行的物理路径。冯诺依曼 (存储程序) → CPU 三因子 (IC/CPI/T) → 缓存层级 (局部性) → GPU 并行 (SIMT)。Ch13 §03 OS 将管理这些硬件资源。

八 · 板书建议¶

[板书 1: 冯诺依曼]
   CPU + 内存 + 总线 + IO
   存储程序

[板书 2: CPU 公式]
   T_CPU = IC × CPI × T_cycle

[板书 3: 内存层级]
   Register → L1 → L2 → L3 → DRAM → SSD → HDD
   1 ns → 1 ns → 10 ns → 30 ns → 100 ns → 100 μs → 10 ms

[板书 4: GPU]
   CPU: 少核高频率
   GPU: 多核低频率 SIMT
   内存墙

九 · 参考资料¶

Hennessy & Patterson, "Computer Architecture: A Quantitative Approach"
NVIDIA H100 白皮书
Ch03 §05 梯度下降 (本套书)
PyTorch Profiler 文档
Linux perf 文档