从显存碎片到吞吐最优：GPU内存管理与性能优化实战 - 第1节

1. 显存碎片初探

各位同学好，我是你们的GPU系统工程师。今天咱们来聊聊一个让无数深度学习工程师头疼的问题——显存碎片。

先问大家一个问题：你训练模型时，有没有遇到过这种情况？明明显存还有好几个GB，但一跑新模型就报"CUDA out of memory"。我刚开始做分布式训练时，就经常被这个问题折磨。后来才发现，罪魁祸首就是显存碎片。

1.1 什么是显存碎片？

说白了，显存碎片就是显存空间被分割成许多不连续的小块。就像你家的衣柜，明明还有空间，但都是些边边角角，放不下大件衣服。

在GPU里，显存分配和释放是动态的。每次你创建张量、加载模型、做前向反向传播，CUDA都会在显存里申请和释放空间。久而久之，显存就被切得七零八落。

我遇到过最夸张的一次，一个8GB的GPU，实际只用了5GB，但申请一个2GB的张量居然失败了。检查后发现，显存里最大的连续空闲块只有1.2GB。这就是碎片化的典型表现。

1.2 显存碎片分哪几种？

根据我的经验，显存碎片主要分两类：

• 内部碎片：分配器给你一块内存，但你用不完。比如你申请100MB，分配器给了128MB的块，那28MB就是内部碎片。CUDA默认按2MB、4MB、8MB这样的粒度分配，很容易产生内部碎片。
• 外部碎片：这是最头疼的。显存里有很多空闲的小块，但都不连续。你想申请一个大块时，这些小块加起来够用，但就是拼不成一个完整的块。

嗯，这里要注意：外部碎片才是影响训练吞吐的元凶。内部碎片虽然浪费空间，但通常不会直接导致OOM。

二、显存碎片如何影响深度学习训练吞吐？

你可能会想：不就是浪费点显存吗？大不了多等一会儿。但实际情况比这严重得多。

2.1 直接影响：OOM导致训练中断

最直接的影响就是训练中断。我见过一个团队，训练一个BERT-large模型，每次跑到第3个epoch就报OOM。他们以为是模型太大，其实是因为前两个epoch产生的碎片把显存搞乱了。

训练中断意味着什么？

• 浪费之前所有计算时间
• 需要重新加载checkpoint
• 可能丢失学习率调度器的状态
• 分布式训练时还要重新同步

我曾经有个项目，因为显存碎片问题，训练效率直接掉了40%。每次中断重跑，光数据加载和预热就要花10分钟。

2.2 间接影响：分配延迟和带宽下降

碎片化还会带来两个隐藏问题：

• 分配延迟增加：CUDA分配器需要花更多时间搜索合适的空闲块。碎片越多，搜索时间越长。我实测过，碎片化严重时，一次cudaMalloc的耗时能从微秒级飙升到毫秒级。
• 内存带宽下降：不连续的内存访问会导致缓存命中率下降。GPU的显存控制器喜欢连续访问模式，碎片化会让它频繁切换地址，带宽利用率可能下降10%-20%。

三、一个简单的实验观察碎片

光说不练假把式。咱们写个简单的CUDA程序，亲眼看看显存碎片是怎么产生的。

3.1 实验设计

这个实验的思路很简单：

1. 先分配几个大块显存
2. 随机释放其中一些块
3. 再尝试分配一个大块
4. 观察分配结果和碎片情况

我习惯用cudaMemGetInfo来查看显存状态，再用cudaMalloc和cudaFree来模拟训练中的分配释放模式。

3.2 代码实现

#include <stdio.h>
#include <cuda_runtime.h>
#include <stdlib.h>
#include <time.h>

// 模拟显存碎片化过程
void simulate_fragmentation() {
    size_t free_before, total_before;
    cudaMemGetInfo(&free_before, &total_before);
    
    printf("初始显存: 空闲 %.2f GB / 总共 %.2f GB\n", 
           free_before/1e9, total_before/1e9);
    
    // 分配10个不同大小的块
    const int NUM_BLOCKS = 10;
    void* ptrs[NUM_BLOCKS];
    size_t sizes[NUM_BLOCKS] = {
        256*1024*1024,   // 256MB
        128*1024*1024,   // 128MB
        512*1024*1024,   // 512MB
        64*1024*1024,    // 64MB
        1024*1024*1024,  // 1GB
        32*1024*1024,    // 32MB
        768*1024*1024,   // 768MB
        16*1024*1024,    // 16MB
        384*1024*1024,   // 384MB
        192*1024*1024    // 192MB
    };
    
    printf("\n=== 阶段1: 分配所有块 ===\n");
    for(int i = 0; i < NUM_BLOCKS; i++) {
        cudaError_t err = cudaMalloc(&ptrs[i], sizes[i]);
        if(err != cudaSuccess) {
            printf("分配块%d失败: %s\n", i, cudaGetErrorString(err));
            ptrs[i] = NULL;
        } else {
            printf("块%d: 分配 %.0f MB 成功\n", i, sizes[i]/1024.0/1024.0);
        }
    }
    
    // 随机释放一些块（模拟训练中的张量释放）
    printf("\n=== 阶段2: 随机释放块 ===\n");
    srand(time(NULL));
    int released = 0;
    for(int i = 0; i < NUM_BLOCKS; i++) {
        if(ptrs[i] != NULL && rand() % 2 == 0) {
            cudaFree(ptrs[i]);
            ptrs[i] = NULL;
            printf("释放块%d (%.0f MB)\n", i, sizes[i]/1024.0/1024.0);
            released++;
        }
    }
    printf("共释放 %d 个块\n", released);
    
    // 查看碎片化后的显存状态
    size_t free_after, total_after;
    cudaMemGetInfo(&free_after, &total_after);
    printf("\n释放后显存: 空闲 %.2f GB / 总共 %.2f GB\n", 
           free_after/1e9, total_after/1e9);
    
    // 尝试分配一个大块（模拟加载大模型）
    printf("\n=== 阶段3: 尝试分配大块 ===\n");
    size_t big_size = 512*1024*1024;  // 512MB
    void* big_ptr;
    cudaError_t err = cudaMalloc(&big_ptr, big_size);
    if(err == cudaSuccess) {
        printf("成功分配 %.0f MB 的大块！\n", big_size/1024.0/1024.0);
        cudaFree(big_ptr);
    } else {
        printf("分配 %.0f MB 失败: %s\n", 
               big_size/1024.0/1024.0, cudaGetErrorString(err));
        printf("虽然空闲显存有 %.2f GB，但可能被碎片化了\n", 
               free_after/1e9);
    }
    
    // 清理
    for(int i = 0; i < NUM_BLOCKS; i++) {
        if(ptrs[i] != NULL) cudaFree(ptrs[i]);
    }
}

int main() {
    printf("=== 显存碎片化实验 ===\n\n");
    simulate_fragmentation();
    return 0;
}

3.3 实验结果分析

我在一台24GB显存的GPU上跑这个实验，典型输出如下：

=== 显存碎片化实验 ===

初始显存: 空闲 23.42 GB / 总共 23.99 GB

=== 阶段1: 分配所有块 ===
块0: 分配 256 MB 成功
块1: 分配 128 MB 成功
块2: 分配 512 MB 成功
块3: 分配 64 MB 成功
块4: 分配 1024 MB 成功
块5: 分配 32 MB 成功
块6: 分配 768 MB 成功
块7: 分配 16 MB 成功
块8: 分配 384 MB 成功
块9: 分配 192 MB 成功

=== 阶段2: 随机释放块 ===
释放块1 (128 MB)
释放块3 (64 MB)
释放块5 (32 MB)
释放块7 (16 MB)
释放块9 (192 MB)
共释放 5 个块

释放后显存: 空闲 11.42 GB / 总共 23.99 GB

=== 阶段3: 尝试分配大块 ===
分配 512 MB 失败: out of memory
虽然空闲显存有 11.42 GB，但可能被碎片化了

看到了吗？明明还有11.42GB空闲，但连512MB都分配不出来。这就是碎片化的威力。

四、知识体系总览

为了让大家对本章内容有个整体认识，我画了张图：

这张图把本章的核心内容串起来了。从定义到分类，再到影响，最后用实验验证。后面的章节，我们会深入探讨如何解决这些问题。

五、小结

今天咱们聊了显存碎片的基本概念：

• 显存碎片就是显存被分割成不连续的小块
• 分内部碎片和外部碎片两种，外部碎片是主要问题
• 碎片化会导致OOM、分配延迟和带宽下降
• 通过一个简单的实验，我们亲眼看到了碎片化的威力

说实话，我第一次遇到这个问题时，还以为是显卡坏了。后来才明白，这是GPU内存管理的固有特性。好在，我们有办法应对它。