计算机组成与体系结构：缓存（Cache）

为什么需要 Cache？

🧱 Cache 的分层设计

🔹 Level 1 Cache（L1 Cache）一级缓存

🔹 Level 2 Cache（L2 Cache）二级缓存

🔹 Level 3 Cache（L3 Cache）三级缓存

Cache 的运行机制

🔄 CPU 核心数量与 Cache 的关系

🔎 Cache 相关术语（Cache-related Terms）

🧠 引用的局部性（ Locality of Reference）

1️⃣ 时间局部性（Temporal Locality）

2️⃣ 空间局部性（Spatial Locality）

为什么需要 Cache？

想象你在玩一个 100GB 的大型 3D 开放世界游戏，比如《赛博朋克 2077》或《原神》。

这个游戏包含：

成千上万张地图贴图；
数百个角色模型；

你可能会想：

我们不能把所有代码都放在主存里吗？

从第一性原理看，这个问题非常自然。我们来分析一下背后的限制：

💡 为什么不能把整个游戏都放进主存？

原因一：主存容量有限

游戏是按需加载的，因为大部分内容你“当前并不会用到”。
比如你现在在城市区域，森林那部分地图用不到，加载了反而浪费空间。

原因二：主存速度不够快

CPU 执行速度以纳秒为单位，而主存（通常是 DRAM）访问延迟达几十甚至上百纳秒。
如果 CPU 每执行一条指令就等几十纳秒，那执行效率会非常低。

这就引出了我们今天的主角：

Cache（缓存）：一种高速小容量的临时存储区域，用于存放“最近正在用”或“即将用到”的数据，让 CPU 不用一直等主存。

🧱 Cache 的分层设计

💡从第一性原理出发：

我们知道，Cache 的设计目标是解决 CPU 和主存（DRAM）之间巨大的速度差。

元件	速度（延迟）
CPU（寄存器）	<1 ns
L1 Cache	1–2 ns
L2 Cache	~5 ns
L3 Cache	10–20 ns
主存 DRAM	50–100 ns

你可以看到，主存的访问时间是 L1 Cache 的几十倍。为了缩小这个“速度鸿沟”，我们引入了多级缓存（Multilevel Cache Architecture）：

🔹 Level 1 Cache（L1 Cache）一级缓存

位置：直接嵌入在 CPU 核心内部，与执行单元关系最紧密。
速度：最快，通常只有 1–2 个 CPU 时钟周期的延迟。
大小：非常小（一般为 16KB–64KB），分为：
- L1I（指令缓存，Instruction Cache）
- L1D（数据缓存，Data Cache）

为什么分为 I/D？

从第一性原理看：

CPU 在执行程序时，“取指”和“取数据”是两条并行路径，如果混在一起会互相干扰。

🔹 Level 2 Cache（L2 Cache）二级缓存

位置：仍在 CPU 核心附近，但通常不嵌入执行单元。
大小：较大（128KB–1MB），统一存储指令和数据。
速度：比 L1 慢，但比主存快，通常延迟在 5–15 个周期之间。

功能：

弥补 L1 空间不足的问题，把 L1 Cache Miss 的数据“接住”。

🔹 Level 3 Cache（L3 Cache）三级缓存

位置：多个核心之间共享的缓存，不再是每个核心私有。
大小：大（2MB–几十 MB）
速度：相对较慢，但比主存快得多。

设计目的：

为多个核心之间的数据共享提供“中转站”。

层级结构图示（逻辑上）：

          CPU Core/   |   \L1I  L1D   -> L2\______/↓L3 (共享)↓Main Memory

层级	中文名	主要作用	特点	与 CPU 距离
L1 Cache	一级缓存	执行级加速，紧贴指令和数据	最小（16~64KB），最快（1ns）	嵌在每个 CPU 核内部
L2 Cache	二级缓存	衔接 L1 和 L3，扩大命中率	中等大小（256KB~1MB），速度快	通常也是每核私有
L3 Cache	三级缓存	跨核心共享、减少主存访问	最大（2MB~64MB），最慢但仍比 RAM 快	多核之间共享

这套结构就像一个数据“梯子”：

越靠近 CPU，越快，但越小；
越远，越大，但越慢。

🧠 从第一性原理讲：

越靠近 CPU 的缓存必须越小越快，以匹配 CPU 的指令节奏；而越远的缓存可以稍慢，但容量要大些，用于存放更多数据。

Cache 的运行机制

我们以 CPU 执行一条指令为例，看看 Cache 是怎么参与工作的：

步骤一：CPU 需要一个数据（比如变量 x）

CPU 发出一个“内存读取请求”：我要取地址 0x1000 的值。

步骤二：先查 L1 Cache（一级缓存）

L1 是最小但最快的缓存（通常在 1ns 内响应）
CPU 立即在 L1 中查找这个地址。

如果找到了，就叫 Cache Hit（命中）

直接读取数据，立即返回！

如果没有找到，就叫 Cache Miss（未命中）

进入下一层：查 L2。

步骤三：L1 Miss → 查 L2 Cache（二级缓存）

L2 比 L1 稍远、稍大、稍慢（通常 5–15ns）。
如果在 L2 找到了 → 把数据送回 L1（便于下次快速访问）。

步骤四：L2 Miss → 查 L3 Cache（三级缓存）

L3 是多核共享的，容量最大，速度较慢（10–20ns 或更高）。
如果找到了 → 同样送回 L2 → 再写进 L1 → 最后给 CPU 用。

步骤五：L3 也 Miss → 去 Main Memory（主存）

如果三层都没命中，说明这块数据根本没在 Cache 中。
系统需要从主存（DRAM）加载数据（延迟可能高达 100ns）。

这就是最典型的 “缓存访问路径”：

CPU → L1 → L2 → L3 → 主存

🔄 CPU 核心数量与 Cache 的关系

现代 CPU 通常不是单核，而是多核结构（Multicore CPU）。

Dual-core（双核）：2 个处理核心
Quad-core（四核）：4 个处理核心
Octa-core（八核）：8 个处理核心

这些术语表示CPU 中的处理核心数量。

那这些核心如何共享和配置 Cache 呢？我们来详细说说：

每个核心都拥有自己的私有缓存（Private Cache）

缓存层级	分配方式	理由
L1 Cache	每个核心独立拥有	距离近、快速访问、不干扰其他核心
L2 Cache	大多数情况下也是私有	帮助每个核心缓存更多数据，防止竞争冲突

多个核心共享 L3 Cache（Shared Cache）

L3 Cache 通常被设计为多核心共享的一层高速缓存。

原因：

可以减少重复缓存：比如多个线程访问同一个数据，不需要每个核心都复制一份。
提供跨核心通信的中转站。

结构示意（以四核为例）：

[Core1]--L1--L2
[Core2]--L1--L2
[Core3]--L1--L2
[Core4]--L1--L2\       |       /↘ L3 Cache ↙↓Main Memory

这和 Cache 有什么关系？

每个核心通常有自己独立的 L1、L2 Cache，而多个核心之间会共享 L3 Cache，如下：

[Core1] --> L1/L2 --\
[Core2] --> L1/L2 ---|--> 共享 L3 Cache
[Core3] --> L1/L2 --/

为什么这样设计？

从第一性原理看：

每个核心有自己的“工作空间”，但也要能互相通信，所以共享 L3 是折中的办法。

这一套缓存层级 + 多核架构，最终的目标只有一个：

让 CPU 每时每刻都能有“足够快”的数据可用，最大化它的执行效率。

🔎 Cache 相关术语（Cache-related Terms）

🏷️ 1. Cache Hit（缓存命中）

当 CPU 需要某个数据，而该数据已经在 Cache 中，就称为命中（Hit）。

🏷️ 2. Cache Miss（缓存未命中）

数据不在 Cache 中，CPU 需要从更下层（比如主存）去取。

Miss 会带来延迟，也叫 Miss Penalty（未命中惩罚）。

🏷️ 3. Tag Directory（标记目录）

每条 Cache 数据都会带一个“Tag”，用于记录该数据来自内存的哪个位置。
Cache 查询时会通过比对 Tag 来判断是否命中。

🏷️ 4. 其他术语（补充说明）：

🏷️ Page Fault（页错误）

当程序要访问的数据既不在 Cache，也不在主存，而是在磁盘（比如换页文件中），就会发生 Page Fault。
此时操作系统需要从磁盘中调入数据，成本极高。

🏷️Page Hit（页命中）

数据在内存页中已经存在，无需调入磁盘。

📌 注意：Page Fault / Page Hit 是虚拟内存管理里的概念，而不是 Cache 的，但它们也体现了内存的层级思想。

🧠 引用的局部性（ Locality of Reference）

为什么 Cache 能提高性能？核心原理是：

程序访问数据时是有“规律”的，而不是随机的。

引用的局部性是指程序在访问内存时，有集中访问某些区域”的倾向。

就是说：程序不会随便乱跳着访问内存，它有“偏好”：

要么访问同一块地方（空间局部性），要么短时间反复访问同样的内容（时间局部性）。

引用局部性分两种：

1️⃣ 时间局部性（Temporal Locality）

如果某个数据刚刚被访问过，很快还会再次被访问。

举例：

一个变量 x 被频繁使用；
一个循环不断用到数组第0项；
函数刚被调用，马上又调用一次。

2️⃣ 空间局部性（Spatial Locality）

如果访问了某个地址，很可能会接着访问它“附近”的地址。

举例：

遍历数组时会依次访问相邻的内存单元；
连续的结构体或局部变量通常排在栈上连续的空间。

计算机为了加快访问速度，就利用这个“局部性原理”，把近期访问的数据（和它附近的数据）放到更快的缓存（Cache）里。

这样，下次再访问这些内容时就更快了。