欢迎光临
我们一直在努力

第四章:TTM分析: 4.7.1 两种空间管理器drm_mm和drm_buddy的应用实战对比

由前面的分析,我们了解到drm中有两种地址空间管理器:drm_mm和drm_buddy。本篇从AMDGPU驱动的实现中具体对比下两者的应用方法和场景。

概述

在 AMDGPU 驱动中,内存管理是核心功能之一。驱动使用了两种不同的 DRM 空间管理器来管理不同类型的内存资源:

  • drm_buddy:用于管理 VRAM(显存) 的物理内存
  • drm_mm:用于管理 GTT(Graphics Translation Table) 的虚拟地址空间

本文档从驱动开发者的角度,通过 AMDGPU 的实际代码,深入分析这两种管理器的设计差异、使用场景和实现细节。


1. 架构概览

1.1 在 AMDGPU 中的位置

amdgpu_device
└── mman (amdgpu_mman)
├── vram_mgr (amdgpu_vram_mgr)
│ └── mm: struct drm_buddy ← 管理 VRAM 物理内存
│
└── gtt_mgr (amdgpu_gtt_mgr)
└── mm: struct drm_mm ← 管理 GTT 虚拟地址空间


2. 数据结构对比

2.1 VRAM Manager (drm_buddy)

struct amdgpu_vram_mgr {
struct ttm_resource_manager manager;
struct drm_buddy mm; // 伙伴系统分配器
struct mutex lock; // 互斥锁保护
struct list_head reservations_pending; // 预留区域
struct list_head reserved_pages;
atomic64_t vis_usage; // 可见 VRAM 使用量
u64 default_page_size; // 默认页大小
struct list_head allocated_vres_list; // 已分配资源列表
};

struct amdgpu_vram_mgr_resource {
struct ttm_resource base;
struct list_head blocks; // drm_buddy_block 链表
unsigned long flags; // DRM_BUDDY_* 标志
struct list_head vres_node;
struct amdgpu_vres_task task; // 任务信息跟踪
};

特点:

  • 每个分配可能包含多个 buddy block(链表形式)
  • Block 大小总是 PAGE_SIZE << order(2 的幂次)
  • 支持碎片整理和自动合并

2.2 GTT Manager (drm_mm)

struct amdgpu_gtt_mgr {
struct ttm_resource_manager manager;
struct drm_mm mm; // 范围管理器
spinlock_t lock; // 自旋锁保护
};

// 使用 TTM 的 range_mgr_node
struct ttm_range_mgr_node {
struct ttm_resource base;
struct drm_mm_node mm_nodes[]; // 通常只有一个节点
};

特点:

  • 每个分配通常只有一个 drm_mm_node
  • 可以精确分配任意大小和对齐
  • 维护多个红黑树用于快速查找

3. 初始化对比

3.1 VRAM Manager 初始化

// 位置:amdgpu_vram_mgr.c
static int amdgpu_vram_mgr_init(struct amdgpu_device *adev)
{
struct amdgpu_vram_mgr *mgr = &adev->mman.vram_mgr;

// 初始化伙伴系统:总大小、最小块大小(PAGE_SIZE)
err = drm_buddy_init(&mgr->mm, man->size, PAGE_SIZE);

mutex_init(&mgr->lock);
INIT_LIST_HEAD(&mgr->reservations_pending);
INIT_LIST_HEAD(&mgr->reserved_pages);
INIT_LIST_HEAD(&mgr->allocated_vres_list);

mgr->default_page_size = PAGE_SIZE;
// …
}

参数说明:

  • man->size:VRAM 总大小(字节)
  • PAGE_SIZE:最小分配粒度,通常是 4KB
  • 伙伴系统会自动计算 max_order

3.2 GTT Manager 初始化

// 位置:amdgpu_gtt_mgr.c
static int amdgpu_gtt_mgr_init(struct amdgpu_device *adev)
{
struct amdgpu_gtt_mgr *mgr = &adev->mman.gtt_mgr;

// 初始化范围管理器:起始地址、大小
drm_mm_init(&mgr->mm, start, size);

spin_lock_init(&mgr->lock);
// …
}

参数说明:

  • start:GTT 地址空间起始位置(通常是 0)
  • size:GTT 地址空间大小(页数)
  • 不需要指定最小粒度,任意大小均可

4. 内存分配对比

4.1 VRAM 分配(使用 drm_buddy)

// 位置:amdgpu_vram_mgr.c
static int amdgpu_vram_mgr_new(struct ttm_resource_manager *man,
struct ttm_buffer_object *tbo,
const struct ttm_place *place,
struct ttm_resource **res)
{
struct amdgpu_vram_mgr *mgr = to_vram_mgr(man);
struct amdgpu_vram_mgr_resource *vres;

vres = kzalloc(sizeof(*vres), GFP_KERNEL);
ttm_resource_init(tbo, place, &vres->base);
INIT_LIST_HEAD(&vres->blocks);

// 设置 drm_buddy 分配标志
if (place->flags & TTM_PL_FLAG_TOPDOWN)
vres->flags |= DRM_BUDDY_TOPDOWN_ALLOCATION;

if (bo->flags & AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS)
vres->flags |= DRM_BUDDY_CONTIGUOUS_ALLOCATION;

if (bo->flags & AMDGPU_GEM_CREATE_VRAM_CLEARED)
vres->flags |= DRM_BUDDY_CLEAR_ALLOCATION;

if (fpfn || lpfn != mgr->mm.size)
vres->flags |= DRM_BUDDY_RANGE_ALLOCATION;

mutex_lock(&mgr->lock);

// 可能需要多次调用来分配所有内存
while (remaining_size) {
size = remaining_size;

// 确定最小块大小
if (tbo->page_alignment)
min_block_size = (u64)tbo->page_alignment << PAGE_SHIFT;
else
min_block_size = mgr->default_page_size;

// 调用 drm_buddy 分配
r = drm_buddy_alloc_blocks(mm, fpfn, lpfn,
size, min_block_size,
&vres->blocks, // 输出:block 链表
vres->flags);

if (unlikely(r == –ENOSPC)) {
// 降级:取消连续分配要求
vres->flags &= ~DRM_BUDDY_CONTIGUOUS_ALLOCATION;
continue;
}

if (unlikely(r))
goto error_free_blocks;

remaining_size -= size;
}

mutex_unlock(&mgr->lock);

*res = &vres->base;
return 0;
}

分配特点:

  • 多块分配:一次分配可能产生多个 drm_buddy_block
  • 粒度限制:所有 block 大小都是 2 的幂次
  • 标志驱动:通过组合标志控制分配行为
  • 自动降级:连续分配失败时可以降级为非连续
  • drm_buddy 分配标志详解:

    标志含义AMDGPU 使用场景
    DRM_BUDDY_RANGE_ALLOCATION 在指定范围内分配 当 fpfn/lpfn 限制地址范围时
    DRM_BUDDY_TOPDOWN_ALLOCATION 从高地址向低地址分配 TTM_PL_FLAG_TOPDOWN 设置时
    DRM_BUDDY_CONTIGUOUS_ALLOCATION 分配物理连续内存 AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS
    DRM_BUDDY_CLEAR_ALLOCATION 分配已清零的内存 AMDGPU_GEM_CREATE_VRAM_CLEARED
    DRM_BUDDY_TRIM_DISABLE 禁止 trim 操作 DCC 对齐场景

    4.2 GTT 分配(使用 drm_mm)

    // 位置:amdgpu_gtt_mgr.c
    static int amdgpu_gtt_mgr_new(struct ttm_resource_manager *man,
    struct ttm_buffer_object *tbo,
    const struct ttm_place *place,
    struct ttm_resource **res)
    {
    struct amdgpu_gtt_mgr *mgr = to_gtt_mgr(man);
    struct ttm_range_mgr_node *node;
    uint32_t num_pages = PFN_UP(tbo->base.size);

    node = kzalloc(struct_size(node, mm_nodes, 1), GFP_KERNEL);
    ttm_resource_init(tbo, place, &node->base);

    if (place->lpfn) {
    // 有地址范围限制时,立即分配
    spin_lock(&mgr->lock);
    r = drm_mm_insert_node_in_range(&mgr->mm,
    &node->mm_nodes[0],
    num_pages, // 页数
    tbo->page_alignment, // 对齐
    0, // color
    place->fpfn, // 起始
    place->lpfn, // 结束
    DRM_MM_INSERT_BEST); // 最佳适配
    spin_unlock(&mgr->lock);

    if (unlikely(r))
    goto err_free;

    node->base.start = node->mm_nodes[0].start;
    } else {
    // 无地址限制时,延迟分配(只记录大小)
    node->mm_nodes[0].start = 0;
    node->mm_nodes[0].size = num_pages;
    node->base.start = AMDGPU_BO_INVALID_OFFSET;
    }

    *res = &node->base;
    return 0;
    }

    分配特点:

  • 单节点分配:一次分配只产生一个 drm_mm_node
  • 精确大小:可以分配任意页数,不需要 2 的幂次
  • 模式选择:通过 drm_mm_insert_mode 控制搜索策略
  • 延迟分配:GTT 可以延迟到真正需要时才分配地址
  • drm_mm 插入模式详解:

    模式含义使用场景
    DRM_MM_INSERT_BEST 最佳适配(最小空洞) GTT 默认模式,减少碎片
    DRM_MM_INSERT_LOW 低地址优先 需要特定地址的场景
    DRM_MM_INSERT_HIGH 高地址优先 从顶部分配
    DRM_MM_INSERT_EVICT 使用最近驱逐的空洞 内存回收场景

    5. 内存释放对比

    5.1 VRAM 释放

    static void amdgpu_vram_mgr_del(struct ttm_resource_manager *man,
    struct ttm_resource *res)
    {
    struct amdgpu_vram_mgr *mgr = to_vram_mgr(man);
    struct amdgpu_vram_mgr_resource *vres = to_amdgpu_vram_mgr_resource(res);
    struct drm_buddy *mm = &mgr->mm;

    mutex_lock(&mgr->lock);

    // 释放所有 buddy blocks
    drm_buddy_free_list(mm, &vres->blocks, vres->flags);

    list_del(&vres->vres_node);
    mutex_unlock(&mgr->lock);

    kfree(vres);
    }

    释放特点:

    • drm_buddy_free_list:批量释放多个 block
    • 自动合并:相邻的空闲块会自动合并成更大的块
    • 释放后可能恢复到更大的 order

    5.2 GTT 释放

    static void amdgpu_gtt_mgr_del(struct ttm_resource_manager *man,
    struct ttm_resource *res)
    {
    struct amdgpu_gtt_mgr *mgr = to_gtt_mgr(man);
    struct ttm_range_mgr_node *node = to_ttm_range_mgr_node(res);

    spin_lock(&mgr->lock);

    if (drm_mm_node_allocated(&node->mm_nodes[0]))
    drm_mm_remove_node(&node->mm_nodes[0]);

    spin_unlock(&mgr->lock);

    kfree(node);
    }

    释放特点:

    • drm_mm_remove_node:移除单个节点
    • 空洞管理:释放后创建一个新的空洞或合并相邻空洞
    • 不会改变相邻已分配节点的大小

    6. 辅助函数对比

    6.1 VRAM 辅助函数

    // 获取 block 的起始地址
    static inline u64 amdgpu_vram_mgr_block_start(struct drm_buddy_block *block)
    {
    return drm_buddy_block_offset(block);
    }

    // 获取 block 的大小
    static inline u64 amdgpu_vram_mgr_block_size(struct drm_buddy_block *block)
    {
    return (u64)PAGE_SIZE << drm_buddy_block_order(block);
    }

    // 检查是否已清零
    static inline bool amdgpu_vram_mgr_is_cleared(struct drm_buddy_block *block)
    {
    return drm_buddy_block_is_clear(block);
    }

    // 检查多个 block 是否连续
    static inline bool amdgpu_is_vram_mgr_blocks_contiguous(struct list_head *head)
    {
    struct drm_buddy_block *block;
    u64 start, size;

    block = amdgpu_vram_mgr_first_block(head);
    if (!block)
    return false;

    while (head != block->link.next) {
    start = amdgpu_vram_mgr_block_start(block);
    size = amdgpu_vram_mgr_block_size(block);

    block = list_entry(block->link.next, struct drm_buddy_block, link);
    if (start + size != amdgpu_vram_mgr_block_start(block))
    return false;
    }

    return true;
    }

    // 计算所有 block 的总大小
    static inline u64 amdgpu_vram_mgr_blocks_size(struct list_head *head)
    {
    struct drm_buddy_block *block;
    u64 size = 0;

    list_for_each_entry(block, head, link)
    size += amdgpu_vram_mgr_block_size(block);

    return size;
    }

    6.2 GTT 辅助函数

    // 检查是否已分配地址
    bool amdgpu_gtt_mgr_has_gart_addr(struct ttm_resource *res)
    {
    struct ttm_range_mgr_node *node = to_ttm_range_mgr_node(res);
    return drm_mm_node_allocated(&node->mm_nodes[0]);
    }

    // drm_mm 提供的遍历宏
    #define drm_mm_for_each_node(entry, mm) \\
    list_for_each_entry(entry, drm_mm_nodes(mm), node_list)

    #define drm_mm_for_each_hole(pos, mm, hole_start, hole_end) \\
    for (pos = list_first_entry(&(mm)->hole_stack, ...


    7. 性能特性对比

    7.1 时间复杂度

    操作drm_buddy (VRAM)drm_mm (GTT)
    初始化 O(1) O(1)
    分配 O(max_order) O(log n) + 可能的线性扫描
    释放 O(log n) O(log n)
    合并 O(log n),自动 O(log n),自动
    查找空洞 O(1) per order O(log n) with RB-tree

    7.2 空间开销

    drm_buddy:

    struct drm_buddy_block {
    u64 header; // 8 bytes:包含 offset、state、order
    struct drm_buddy_block *left; // 8 bytes
    struct drm_buddy_block *right; // 8 bytes
    struct drm_buddy_block *parent;// 8 bytes
    void *private; // 8 bytes
    struct list_head link; // 16 bytes
    struct list_head tmp_link; // 16 bytes
    };
    // 总计:72 bytes per block

    drm_mm:

    struct drm_mm_node {
    unsigned long color; // 8 bytes
    u64 start; // 8 bytes
    u64 size; // 8 bytes
    struct drm_mm *mm; // 8 bytes
    struct list_head node_list; // 16 bytes
    struct list_head hole_stack; // 16 bytes
    struct rb_node rb; // 24 bytes (3 pointers)
    struct rb_node rb_hole_size; // 24 bytes
    struct rb_node rb_hole_addr; // 24 bytes
    u64 __subtree_last; // 8 bytes
    u64 hole_size; // 8 bytes
    u64 subtree_max_hole; // 8 bytes
    unsigned long flags; // 8 bytes
    // 总计:~168 bytes per node
    };

    结论:

    • drm_mm 节点更大,但通常每次分配只有一个节点
    • drm_buddy 块更小,但可能需要多个块
    • VRAM 大块分配时,drm_buddy 更节省空间

    7.3 碎片化特性

    drm_buddy (VRAM):

    • ✅ 优势:伙伴系统自然抗碎片化
    • ✅ 自动合并相邻空闲块
    • ✅ 2 的幂次分配减少外部碎片
    • ⚠️ 内部碎片:请求 5KB 会分配 8KB

    drm_mm (GTT):

    • ✅ 优势:精确分配,无内部碎片
    • ✅ 多种搜索策略优化
    • ⚠️ 长时间运行后可能产生外部碎片
    • ⚠️ 需要驱逐机制来整理碎片

    8. 锁机制对比

    8.1 VRAM 使用 Mutex

    struct amdgpu_vram_mgr {
    struct mutex lock; // 互斥锁
    };

    // 使用场景:
    mutex_lock(&mgr->lock);
    drm_buddy_alloc_blocks(...); // 可能睡眠
    drm_buddy_free_list(...);
    mutex_unlock(&mgr->lock);

    原因:

    • VRAM 分配可能需要复杂操作(清零、DCC 对齐等)
    • 可以睡眠的上下文
    • 分配时间较长

    8.2 GTT 使用 Spinlock

    struct amdgpu_gtt_mgr {
    spinlock_t lock; // 自旋锁
    };

    // 使用场景:
    spin_lock(&mgr->lock);
    drm_mm_insert_node_in_range(...); // 不能睡眠
    spin_unlock(&mgr->lock);

    原因:

    • GTT 分配是纯地址分配,操作快速
    • 可能在中断上下文调用
    • 需要更低的延迟

    9. 高级特性

    9.1 VRAM 独有特性

    9.1.1 Block Trim(DCC 对齐)

    // GFX12 DCC 场景需要特殊对齐
    if (bo->flags & AMDGPU_GEM_CREATE_GFX12_DCC) {
    adjust_dcc_size = amdgpu_gmc_get_dcc_alignment(adev);

    // 分配更大的块
    dcc_size = roundup_pow_of_two(vres->base.size + adjust_dcc_size);
    remaining_size = (u64)dcc_size;
    vres->flags |= DRM_BUDDY_TRIM_DISABLE;

    // 分配后 trim 到实际需要的大小
    drm_buddy_block_trim(mm, &trim_start,
    (u64)vres->base.size,
    &vres->blocks);
    }

    用途:为 DCC (Display Compression Controller) 元数据预留对齐空间

    9.1.2 预留区域

    struct amdgpu_vram_reservation {
    u64 start;
    u64 size;
    struct list_head allocated;
    struct list_head blocks;
    };

    // 预留 VRAM 区域(如 stolen memory)
    static int amdgpu_vram_mgr_reserve_range(...)
    {
    list_for_each_entry(rsv, &mgr->reservations_pending, blocks) {
    if (drm_buddy_alloc_blocks(mm, rsv->start, rsv->start + rsv->size,
    rsv->size, mm->chunk_size, &rsv->allocated,
    DRM_BUDDY_RANGE_ALLOCATION))
    return –ENOMEM;
    }
    }

    9.1.3 清零追踪

    // 检查 block 是否已清零
    if (bo->flags & AMDGPU_GEM_CREATE_VRAM_CLEARED) {
    vres->flags |= DRM_BUDDY_CLEAR_ALLOCATION;
    }

    // drm_buddy 内部维护清零状态
    if (amdgpu_vram_mgr_is_cleared(block)) {
    // 可以跳过清零操作
    }

    9.2 GTT 独有特性

    9.2.1 延迟地址分配

    // 第一阶段:只分配资源对象,不分配地址
    if (!place->lpfn) {
    node->mm_nodes[0].start = 0;
    node->mm_nodes[0].size = num_pages;
    node->base.start = AMDGPU_BO_INVALID_OFFSET; // 标记为未分配
    }

    // 第二阶段:真正需要时再分配地址(通过 GART bind)
    if (!amdgpu_gtt_mgr_has_gart_addr(res)) {
    // 现在才调用 drm_mm_insert_node_in_range
    }

    优势:

    • 减少 GTT 地址空间压力
    • 只在真正需要 GART 映射时才分配地址
    • 支持 overcommit
    9.2.2 Color Adjustment(未在 AMDGPU 中使用)

    // drm_mm 支持但 AMDGPU GTT 未启用
    struct drm_mm {
    void (*color_adjust)(const struct drm_mm_node *node,
    unsigned long color,
    u64 *start, u64 *end);
    };

    // 可用于插入 guard pages 或对齐调整


    10. 资源遍历

    10.1 VRAM 资源遍历(多个 blocks)

    #include "amdgpu_res_cursor.h"

    // 使用统一的 cursor 接口遍历 buddy blocks
    struct amdgpu_res_cursor cursor;

    amdgpu_res_first(&vres->base, 0, size, &cursor);
    while (cursor.remaining) {
    u64 start = cursor.start; // 当前 block 起始地址
    u64 size = cursor.size; // 当前 block 大小

    // 处理当前 block…

    amdgpu_res_next(&cursor, size);
    }

    内部实现(简化):

    struct amdgpu_res_cursor {
    void *mem; // 指向 blocks 链表
    struct drm_buddy_block *block; // 当前 block
    u64 start;
    u64 size;
    u64 remaining;
    };

    // 初始化:指向第一个 block
    cursor->block = list_entry(cursor->mem, struct drm_buddy_block, link);

    // 迭代:移动到下一个 block
    cursor->block = list_entry(next, struct drm_buddy_block, link);

    10.2 GTT 资源遍历(单个 node)

    struct ttm_range_mgr_node *node = to_ttm_range_mgr_node(res);
    struct drm_mm_node *mm_node = &node->mm_nodes[0];

    // 通常只有一个节点,直接访问
    u64 start = mm_node->start;
    u64 size = mm_node->size;


    11. 调试和诊断

    11.1 VRAM 调试接口

    // Sysfs 属性
    static DEVICE_ATTR(mem_info_vram_total, S_IRUGO, ...);
    static DEVICE_ATTR(mem_info_vram_used, S_IRUGO, ...);
    static DEVICE_ATTR(mem_info_vis_vram_total, S_IRUGO, ...);
    static DEVICE_ATTR(mem_info_vis_vram_used, S_IRUGO, ...);

    // 读取方式:
    // cat /sys/class/drm/card0/device/mem_info_vram_total
    // cat /sys/class/drm/card0/device/mem_info_vram_used

    // 打印 buddy 状态
    void drm_buddy_print(struct drm_buddy *mm, struct drm_printer *p);

    // 任务追踪
    vres->task.pid = task_pid_nr(current);
    get_task_comm(vres->task.comm, current);

    11.2 GTT 调试接口

    // Sysfs 属性
    static DEVICE_ATTR(mem_info_gtt_total, S_IRUGO, ...);
    static DEVICE_ATTR(mem_info_gtt_used, S_IRUGO, ...);

    // 打印 drm_mm 状态
    void drm_mm_print(struct drm_mm *mm, struct drm_printer *p);

    // 遍历所有节点
    struct drm_mm_node *mm_node;
    drm_mm_for_each_node(mm_node, &mgr->mm) {
    // 检查节点信息
    }


    12. 使用场景决策树

    需要分配内存?
    ├─ 物理显存 (VRAM)
    │ ├─ 使用 drm_buddy
    │ ├─ 适合场景:
    │ │ ✓ 大块连续内存(帧缓冲区)
    │ │ ✓ 需要清零的内存
    │ │ ✓ 可以接受 2 的幂次对齐
    │ │ ✓ 需要碎片整理
    │ └─ API:drm_buddy_alloc_blocks()
    │
    └─ 虚拟地址空间 (GTT/VM)
    ├─ 使用 drm_mm
    ├─ 适合场景:
    │ ✓ 精确大小分配
    │ ✓ 需要特定地址范围
    │ ✓ 虚拟地址映射
    │ ✓ 延迟分配支持
    └─ API:drm_mm_insert_node_in_range()


    13. 常见陷阱和最佳实践

    13.1 VRAM 陷阱

    ❌ 错误:假设单次分配只返回一个 block

    struct drm_buddy_block *block = list_first_entry(&vres->blocks, ...);
    u64 addr = amdgpu_vram_mgr_block_start(block); // 只获取第一个!

    ✅ 正确:遍历所有 blocks

    struct drm_buddy_block *block;
    list_for_each_entry(block, &vres->blocks, link) {
    u64 addr = amdgpu_vram_mgr_block_start(block);
    u64 size = amdgpu_vram_mgr_block_size(block);
    // 处理每个 block
    }

    ❌ 错误:不检查连续性

    // 假设 blocks 总是连续的

    ✅ 正确:显式检查或请求连续分配

    if (need_contiguous) {
    bo->flags |= AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS;
    }
    // 或
    if (!amdgpu_is_vram_mgr_blocks_contiguous(&vres->blocks)) {
    // 处理非连续情况
    }

    13.2 GTT 陷阱

    ❌ 错误:假设地址已分配

    struct ttm_range_mgr_node *node = to_ttm_range_mgr_node(res);
    u64 addr = node->mm_nodes[0].start; // 可能是 0!

    ✅ 正确:检查分配状态

    if (amdgpu_gtt_mgr_has_gart_addr(res)) {
    u64 addr = node->mm_nodes[0].start;
    // 使用地址
    } else {
    // 需要先 bind
    }

    13.3 锁使用陷阱

    ❌ 错误:在 spinlock 中睡眠

    spin_lock(&gtt_mgr->lock);
    might_sleep_function(); // BUG!
    spin_unlock(&gtt_mgr->lock);

    ✅ 正确:理解上下文

    // VRAM:可以睡眠
    mutex_lock(&vram_mgr->lock);
    might_sleep_function(); // OK
    mutex_unlock(&vram_mgr->lock);

    // GTT:不能睡眠
    spin_lock(&gtt_mgr->lock);
    fast_operation_only(); // OK
    spin_unlock(&gtt_mgr->lock);


    14. 实战案例

    案例 1:分配 64MB 连续 VRAM 用于帧缓冲

    struct amdgpu_bo_param bp = {
    .size = 64 * 1024 * 1024,
    .domain = AMDGPU_GEM_DOMAIN_VRAM,
    .flags = AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS,
    // …
    };

    // 最终会调用 amdgpu_vram_mgr_new
    // 1. 设置 DRM_BUDDY_CONTIGUOUS_ALLOCATION
    // 2. drm_buddy_alloc_blocks 返回连续的物理 block(s)
    // 3. 可能是 1 个 64MB block(如果是 2^26)
    // 或多个较小的连续 blocks

    案例 2:分配 GTT 用于 CPU-GPU 传输

    struct amdgpu_bo_param bp = {
    .size = 4 * 1024 * 1024, // 4MB
    .domain = AMDGPU_GEM_DOMAIN_GTT,
    // …
    };

    // 最终会调用 amdgpu_gtt_mgr_new
    // 1. 如果没有 fpfn/lpfn,延迟分配地址
    // 2. 只分配 ttm_resource,start = INVALID_OFFSET
    // 3. 真正 bind 时才调用 drm_mm_insert_node_in_range

    案例 3:预留 VRAM 用于 Stolen Memory

    // 系统启动时预留一部分 VRAM
    static int amdgpu_vram_mgr_reserve_stolen(struct amdgpu_device *adev)
    {
    struct amdgpu_vram_mgr *mgr = &adev->mman.vram_mgr;
    struct amdgpu_vram_reservation rsv;

    rsv.start = 0;
    rsv.size = adev->stolen_vga_size;

    // 使用 RANGE_ALLOCATION 强制分配特定区域
    drm_buddy_alloc_blocks(&mgr->mm, rsv.start, rsv.start + rsv.size,
    rsv.size, PAGE_SIZE, &rsv.allocated,
    DRM_BUDDY_RANGE_ALLOCATION);

    list_add(&rsv.blocks, &mgr->reserved_pages);
    }


    15. 性能优化建议

    15.1 VRAM 优化

  • 合理使用连续分配

    • 只在真正需要时使用 CONTIGUOUS
    • 非连续分配更灵活,碎片化更少
  • 利用清零标志

    if (need_cleared) {
    bo->flags |= AMDGPU_GEM_CREATE_VRAM_CLEARED;
    // drm_buddy 会优先返回已清零的 blocks
    }

  • 减少小块分配

    • 小块分配会增加元数据开销
    • 尽量批量分配或使用内存池
  • 15.2 GTT 优化

  • 使用延迟分配

    • 不设置 fpfn/lpfn,让 GTT 延迟分配地址
    • 减少地址空间碎片
  • 选择合适的插入模式

    // 快速分配:使用 BEST_FIT(默认)
    DRM_MM_INSERT_BEST

    // 特定需求:
    DRM_MM_INSERT_HIGH // TOPDOWN
    DRM_MM_INSERT_LOW // BOTTOM-UP

  • 批量操作

    • 尽量减少锁竞争
    • 批量分配/释放

  • 16. 总结

    维度drm_buddy (VRAM)drm_mm (GTT)
    管理对象 物理显存 虚拟地址空间
    算法 伙伴系统 区间树 + 红黑树
    分配粒度 2 的幂次(PAGE_SIZE << order) 任意大小(页数)
    分配结果 多个 blocks(链表) 单个 node
    内存开销 72 bytes/block 168 bytes/node
    碎片化 内部碎片,但自动合并 无内部碎片,可能外部碎片
    锁机制 Mutex(可睡眠) Spinlock(不可睡眠)
    特殊功能 清零追踪、预留区域、trim 延迟分配、color adjust
    典型场景 帧缓冲、纹理、大块数据 GART 映射、虚拟地址管理

    关键要点

  • 选择正确的管理器:

    • VRAM 物理内存 → drm_buddy
    • GTT/VM 虚拟地址 → drm_mm
  • 理解分配语义:

    • drm_buddy:可能返回多个 blocks,需要遍历
    • drm_mm:通常返回单个 node,可能延迟分配
  • 注意锁上下文:

    • VRAM:mutex,可以睡眠
    • GTT:spinlock,必须原子操作
  • 利用高级特性:

    • VRAM:清零追踪、连续分配、DCC 对齐
    • GTT:延迟分配、灵活的插入模式
  • 调试方法:

    • 使用 sysfs 接口监控使用量
    • 使用 drm_buddy_print / drm_mm_print 查看内部状态
    • 启用 CONFIG_DRM_DEBUG_MM 获取更多信息

  • 赞(0)
    未经允许不得转载:171主机测评 » 第四章:TTM分析: 4.7.1 两种空间管理器drm_mm和drm_buddy的应用实战对比
    分享到: 更多 (0)

    评论 抢沙发

    • 昵称 (必填)
    • 邮箱 (必填)
    • 网址