GPU架构：显存层次

可视化演示

展示NPU（神经网络处理器）核心的脉动阵列架构，包含MAC计算单元数据流、输入权重加载过程，以及NPU与GPU/CPU在AI推理场景下的性能对比。

层次总览：芯片城市的四级仓储

想象一座芯片城市，计算单元（SM）是繁忙的车间，每个车间里有几十个“工人线程”。他们干活需要原料——数据。原料放在哪里，决定了工人能否流畅干活。于是城市建了四层仓储：工人腰间工具袋、车间公用工作台、街角便利店社区超市、以及郊区中央仓库。这四级仓储从近到远、从贵到便宜、从快到慢，彼此配合构成了显存层次。

GPU 的显存层次可以粗分两类：片上存储（寄存器、共享内存、L1/L2 缓存）和片外存储（全局内存）。凡是物理上离计算单元越近的层级，容量越小、造价越贵、速度越快；离得越远，容量越大、速度越慢。程序员最关心的是“一次访存要等多少个周期”，而这串数字跨越了三个数量级。

所以 GPU 程序优化的本质，就是尽可能让工人使用腰包和工作台，少去中央仓库。理解了这张“价格表”，你就握住了显存优化的钥匙。

寄存器：工人腰间的工具袋

每个工人线程腰间挂着一个迷你工具袋——寄存器文件。它是最私密、最快速的存储：只有自己能用，别人碰不到。GPU 为每个线程分配若干寄存器，访问它们只要 1 个周期，几乎不影响性能。但工具袋的容量极其有限：一个线程通常只能分到几十个寄存器，超过限制就被“挤出”或降速。

寄存器文件在每个 SM 里总容量固定，比如 65536 个 32 位寄存器。每个线程用多少寄存器，直接决定一个 SM 能同时驻留多少线程：

举例：65536 个寄存器，每人 32 个，能驻留 2048 线程；如果 kernel 写得寄存器爆炸、每人用 128 个，驻留线程骤降到 512，延迟就无法被大量线程掩盖。所以优化要“抠门”：少用寄存器，把资源还给并行度。

共享内存：车间公用的工作台

同一车间的工人们（一个线程块）身边有一张大家共用的工作台——共享内存。它由程序员显式管理，擅长让线程之间交换数据、协作完成同一项任务。共享内存访问延迟约 20 个周期，远快于全局内存，但每 SM 只有几十 KB，容量很紧张。

这张工作台的奇特之处在于它有 32 个“抽屉”（存储体，bank）。如果 32 个线程同时访问 32 个不同抽屉的数据，一次就能完成；但如果两个线程恰好访问同一抽屉的两个不同地址，就会发生存储体冲突，访问被迫串行执行：

所以用共享内存时，要精心设计索引，让同一时刻访问的地址分散在 32 个银行中，避免挤在同一个抽屉里排队。

缓存层次：街角便利店与社区超市

芯片城市里还开着两家“自动补货”的超市：L1 缓存是每个车间门口的街角便利店，容量几十 KB，延迟约 30 周期；L2 缓存是服务全城的社区超市，容量几 MB，延迟约 200 周期。它们都由硬件自动管理，不需要程序员显式搬运，配合“缓存行”机制把连续数据成批拉近。

缓存的价值在于命中与未命中。命中了，数据在近处直接取用；未命中，就要去更远的层级搬一次。整体平均访存延迟可以这样估算：

理解缓存的“自动补货”逻辑后，你就明白为什么要写“对缓存友好”的代码：多访问同一块数据、多访问连续地址，让便利店多命中几次，少跑社区超市。

全局内存：郊区的中央仓库

全局内存在 GPU 的显存层次中扮演“终极大仓库”的角色：容量最大（几十 GB），价格最便宜，但延迟也最高（400～800 周期）。GPU 与全局内存之间有高带宽总线，比如 HBM 可以有每秒数 TB 的带宽，但前提是你能“装满每一辆卡车”——这就是合并访问。

现代 GPU 按 32 字节扇区从全局内存取数据。如果一个线程束（32 个线程）访问的地址是连续的、对齐的，硬件就能用最少的事务把数据一次搬回。反之，如果线程东跳一个、西跳一个，同一辆卡车只装了几件货，效率自然暴跌：

写核函数时，尽量让相邻线程访问相邻地址，让每次全局内存访问都像“满载卡车”一样高效。这是 GPU 编程中最经典的性能口诀之一。

局部性原理：熟悉的人和邻居

缓存和工作台之所以快，靠的是两条朴素的规律：时间局部性——刚用过的东西很可能马上再用；空间局部性——用了一个数据，旁边的数据大概率也要用。就像工人喜欢把常用工具放在手边，买东西会一次把相邻货架扫一遍。

局部性决定了程序属于“计算密集”还是“内存密集”。衡量这一性质的核心指标是算术强度：

掌握算术强度，你就拥有了判断“瓶颈在哪”的第一把尺子：搬数据的时间远大于算数据的时间时，任何计算优化都是杯水车薪。

优化策略：仓管员的搬运艺术

一个经验丰富的仓管员不会让工人每次都跑去中央仓库取一件货，而是会统筹规划：先把一批货搬到车间工作台，让工人就地取用多次。这套思路对应 GPU 优化的两大招：数据复用和分块。把要反复使用的数据切成小块载入共享内存，每次处理一小块，积少成多把全局流量压低几十倍。

那到底该优化计算还是优化访存？用 Roofline 模型一画便知：横轴是算术强度，纵轴是可达性能。性能不会超过天花板——计算峰值和带宽上限的交界处：

分块后数据留在共享内存里反复复用，$I$ 上升，程序从陡坡段爬向平台段。这就是仓管员的智慧：与其跑一百趟，不如一次搬一箱。

深度学习实践：大模型时代的显存兵法

深度学习的主力运算是矩阵乘法和卷积，它们的共同特点是数据复用潜力巨大。一个 $N \times N$ 的矩阵乘法，若不优化要反复读写全局内存；用分块策略后，每个数据块在共享内存中被复用 $N/tile$ 次，全局搬运量大幅下降。其算术强度近似：

这正是 FlashAttention 等高效算子的根基：把大矩阵切成小块，让数据尽量停留在共享内存，把全局内存的访问量从 $O(N^2)$ 降到 $O(N)$。训练大模型时，显存层次的运用已然是兵家必争之地——谁的数据离计算更近，谁就能跑得更快。

AI 应用场景

Python 演示

def matmul_traffic(N, tile):    """估算矩阵乘法的 DRAM 流量（字节）。     参数:        N: 矩阵边长（N x N）        tile: 分块边长；0 表示朴素实现（不分块）    返回:        理论 DRAM 流量（字节）    """    if tile == 0:        # 朴素实现：每个 A/B 元素都被全局读写 O(N) 次        a_flow = N ** 3        b_flow = N ** 3        c_flow = N ** 2    else:        # 分块实现：A/B 各被复用 N/tile 次        a_flow = N ** 3 / tile        b_flow = N ** 3 / tile        c_flow = N ** 2    return (a_flow + b_flow + c_flow) * 4  # float32 每元素 4 字节  def main():    N = 1024    print(f"N={N} 的矩阵乘法，对比不同分块大小：")    for tile in [0, 16, 64]:        bytes_flow = matmul_traffic(N, tile)        gb = bytes_flow / 1e9        # 假设可用带宽为 1 TB/s，计算理想耗时        ms = gb / 1.0 * 1000        print(f"tile={tile:>2}  DRAM流量 {gb:8.2f} GB, 理想耗时 {ms:8.2f} ms")  if __name__ == "__main__":    main()

1. a_flow = N ** 3朴素实现中每个 A 元素在 k 循环里被反复读取 N 次，总量为 N³。
2. a_flow = N ** 3 / tile分块后 A 的每个子块被载入共享内存一次、复用 tile² 次，流量下降约 tile 倍。
3. (a_flow + b_flow + c_flow) * 4将“元素访问次数”换算成字节数（float32 占 4 字节）。
4. ms = gb / 1.0 * 1000假设 1TB/s 可用带宽，把流量换算成理想耗时，直观量化优化收益。

常见误区

面试题