由前面的分析,我们了解到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 分配标志详解:
| 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 插入模式详解:
| 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 时间复杂度
| 初始化 | 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(>t_mgr->lock);
might_sleep_function(); // BUG!
spin_unlock(>t_mgr->lock);
✅ 正确:理解上下文
// VRAM:可以睡眠
mutex_lock(&vram_mgr->lock);
might_sleep_function(); // OK
mutex_unlock(&vram_mgr->lock);
// GTT:不能睡眠
spin_lock(>t_mgr->lock);
fast_operation_only(); // OK
spin_unlock(>t_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. 总结
| 管理对象 | 物理显存 | 虚拟地址空间 |
| 算法 | 伙伴系统 | 区间树 + 红黑树 |
| 分配粒度 | 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 获取更多信息