1. ttm_resource_manager的功能
在前面的文章中,我们分析了 TTM 的核心组件:
- ttm_buffer_object:GPU 内存对象的核心抽象
- ttm_resource:描述物理资源的位置和属性
今天我们要深入探讨连接这两者的关键组件——ttm_resource_manager(资源管理器)。
GPU 驱动需要管理多种类型的内存域:
- VRAM(显存):GPU 专用的板载内存,速度快但容量有限
- GTT(GPU Translation Table):通过 GART/IOMMU 映射的系统内存
- SYSTEM(系统内存):普通的 CPU 可访问内存
核心问题:
- 如何统一管理这些不同特性的内存域?
- VRAM 需要复杂的碎片管理(Buddy Allocator),GTT 只需要地址区间管理
- SYSTEM 内存只需要页分配,几乎没有管理开销
- 如何设计一个既灵活又高效的抽象?
核心结论:
ttm_resource_manager 是 TTM 对内存域的统一抽象。
它定义了资源分配/释放的标准接口(ttm_resource_manager_func),允许不同内存域使用不同的分配策略:
- VRAM:Buddy Allocator(AMD 驱动实现)或 Range Manager
- GTT:Range Manager(drm_mm 地址区间管理)
- SYSTEM:简单的 kzalloc(几乎没有管理逻辑)
每个 ttm_device 维护多个 resource manager(每个内存域一个),统一对外提供 ttm_resource_alloc() 接口。
2. ttm_resource_manager 核心结构体详解
2.1 结构体定义剖析
/**
* struct ttm_resource_manager
*/
struct ttm_resource_manager {
//常量(初始化后不变)
bool use_type; // 是否启用该内存域 ★
bool use_tt; // 是否需要 ttm_tt ★
struct ttm_device *bdev; // 所属 TTM 设备
uint64_t size; // 总大小(字节)★
const struct ttm_resource_manager_func *func; // 操作函数表 ★★
spinlock_t move_lock; // move fence 的锁
// 受 @move_lock 保护
struct dma_fence *move; // 最近的移动操作 fence
// 受 bdev->lru_lock 保护
struct list_head lru[TTM_MAX_BO_PRIORITY]; // 4 个优先级的 LRU 链表 ★
// @usage: 已使用的资源量,受 bdev->lru_lock 保护
uint64_t usage; // 当前使用量(字节)★
// @cg: dmem_cgroup_region 用于内存统计
struct dmem_cgroup_region *cg; // cgroup 内存统计
};
2.2 字段详细解析
2.2.1 配置与能力
| use_type | bool | 是否启用 | false:该内存域不可用true:可以分配资源通过 ttm_resource_manager_set_used() 设置 |
| use_tt | bool | 是否需要 ttm_tt | VRAM: false(直接访问显存,不需要页表)GTT: true(需要 ttm_tt 管理物理页)SYSTEM: true(需要 ttm_tt 管理物理页) |
| size | uint64_t | 管理的内存大小 | VRAM: 显存总大小(如 8GB)GTT: GART 地址空间大小(通常 = 系统内存大小)SYSTEM: 0(无限制,取决于系统内存) |
| bdev | struct ttm_device * | 所属 TTM 设备 | 反向引用,用于访问全局锁、页池等 |
2.2.2 操作函数表
| func | const struct ttm_resource_manager_func * | 操作函数表 | 最重要的字段!定义了:- alloc:分配资源- free:释放资源- intersects:判断是否相交- compatible:判断是否兼容- debug:调试信息详见 2.3 节 |
2.2.3 状态与统计
| usage | uint64_t | 当前使用量(字节) | 受 bdev->lru_lock 保护每次 alloc 增加,free 减少用于判断内存是否充足 |
| lru[4] | struct list_head | LRU 链表数组 | 4 个优先级(详见 2.2.4)受 bdev->lru_lock 保护用于 eviction 时选择驱逐目标 |
2.2.4 LRU 优先级
TTM 使用 4 个优先级的 LRU 链表管理 BO:
#define TTM_MAX_BO_PRIORITY 4
enum ttm_bo_priority {
TTM_BO_PRIORITY_SYSTEM = 0, // 系统保留
TTM_BO_PRIORITY_KERNEL = 1, // 内核使用
TTM_BO_PRIORITY_NORMAL = 2, // 普通应用
TTM_BO_PRIORITY_EVICT = 3 // 可驱逐
};
优先级对比:
| SYSTEM | 0 | 系统保留 | 固件、系统关键数据 | 最后驱逐 |
| KERNEL | 1 | 内核使用 | 页表、环形缓冲区 | 后驱逐 |
| NORMAL | 2 | 普通应用 | 渲染目标、纹理、顶点缓冲区 | 正常驱逐 |
| EVICT | 3 | 可驱逐 | 临时缓冲区、缓存 | 优先驱逐 |
LRU 管理:
- 每个资源(ttm_resource)通过 lru 字段链接到对应优先级的链表
- 最近使用的 BO 在链表尾部,最久未使用的在链表头部
- Eviction 时从高优先级(3)到低优先级(0)遍历,选择链表头部的 BO 驱逐
2.2.5 移动同步
| move_lock | spinlock_t | move fence 的锁 | 保护 move 字段 |
| move | struct dma_fence * | 最近的移动 fence | 用于管线化内存移动后续分配可能需要等待该 fence |
2.3 操作函数表:ttm_resource_manager_func
/**
* struct ttm_resource_manager_func – 资源管理器操作函数表
*/
struct ttm_resource_manager_func {
/**
* alloc – 分配资源 ★★
* @man: 资源管理器指针
* @bo: 要分配资源的 BO
* @place: 放置要求(地址范围、标志等)
* @res: 输出:分配的 ttm_resource
*
* 在该内存域分配空间。成功时返回 0,填充 @res。
* 失败时返回:
* – -ENOSPC: 空间不足
* – -ENOMEM: 系统内存不足
*
* 不能在原子上下文调用,需要自己处理锁。
*/
int (*alloc)(struct ttm_resource_manager *man,
struct ttm_buffer_object *bo,
const struct ttm_place *place,
struct ttm_resource **res);
/**
* free – 释放资源 ★★
* @man: 资源管理器指针
* @res: 要释放的 ttm_resource
*
* 释放之前分配的资源。
* 不能在原子上下文调用。
*/
void (*free)(struct ttm_resource_manager *man,
struct ttm_resource *res);
/**
* intersects – 判断是否相交 ★
* @man: 资源管理器指针
* @res: 现有资源
* @place: 放置要求
* @size: 检查的大小
*
* 判断 @res 是否与 @place + @size 相交。
* 用于 eviction:如果不相交,驱逐该 BO 没有意义。
*/
bool (*intersects)(struct ttm_resource_manager *man,
struct ttm_resource *res,
const struct ttm_place *place,
size_t size);
/**
* compatible – 判断是否兼容 ★
* @man: 资源管理器指针
* @res: 现有资源
* @place: 放置要求
* @size: 检查的大小
*
* 判断 @res 是否与 @place + @size 兼容。
* 用于判断是否需要迁移:如果兼容,BO 可以留在原地。
*/
bool (*compatible)(struct ttm_resource_manager *man,
struct ttm_resource *res,
const struct ttm_place *place,
size_t size);
/**
* debug – 打印调试信息
* @man: 资源管理器指针
* @printer: 打印器
*
* 打印该内存域的状态信息(使用量、碎片情况等)。
*/
void (*debug)(struct ttm_resource_manager *man,
struct drm_printer *printer);
};
函数重要性排序:
3. 三种资源管理器的实现
TTM 内核提供了三种资源管理器实现,对应三种内存域的不同特性:
| VRAM Manager | VRAM | amdgpu_vram_mgr.c(驱动特定) | Buddy Allocator | 高 |
| Range Manager | GTT | ttm_range_manager.c | drm_mm 区间管理 | 中 |
| System Manager | SYSTEM | ttm_sys_manager.c | 简单 kzalloc | 低 |
3.1 System Manager:最简单的实现
3.1.1 设计哲学
SYSTEM 内存的特点:
- 使用普通的系统内存(通过 alloc_pages() 分配)
- 几乎没有地址空间管理(由内核 MM 处理)
- 不需要追踪物理位置(ttm_resource::start 无意义)
- 只需要记录分配了多少内存
实现策略:
- alloc:简单的 kzalloc(sizeof(ttm_resource))
- free:简单的 kfree()
- 不需要 intersects、compatible(继承默认行为)
3.1.2 完整实现
/* drivers/gpu/drm/ttm/ttm_sys_manager.c */
/**
* ttm_sys_man_alloc – SYSTEM 内存分配
* @man: 资源管理器
* @bo: 目标 BO
* @place: 放置要求(SYSTEM 场景基本忽略)
* @res: 输出资源
*
* 返回: 0 成功,-ENOMEM 失败
*/
static int ttm_sys_man_alloc(struct ttm_resource_manager *man,
struct ttm_buffer_object *bo,
const struct ttm_place *place,
struct ttm_resource **res)
{
// 1. 分配 ttm_resource 结构体
*res = kzalloc(sizeof(**res), GFP_KERNEL);
if (!*res)
return –ENOMEM;
// 2. 初始化资源(设置 mem_type、size 等)
ttm_resource_init(bo, place, *res);
// 注意:start 字段不设置(SYSTEM 无物理地址概念)
return 0;
}
/**
* ttm_sys_man_free – SYSTEM 内存释放
* @man: 资源管理器
* @res: 要释放的资源
*/
static void ttm_sys_man_free(struct ttm_resource_manager *man,
struct ttm_resource *res)
{
// 1. 清理资源(从 LRU 移除等)
ttm_resource_fini(man, res);
// 2. 释放结构体
kfree(res);
}
/**
* ttm_sys_manager_func – SYSTEM 管理器的函数表
*/
static const struct ttm_resource_manager_func ttm_sys_manager_func = {
.alloc = ttm_sys_man_alloc,
.free = ttm_sys_man_free,
// intersects、compatible、debug 使用默认实现
};
/**
* ttm_sys_man_init – 初始化 SYSTEM 管理器
* @bdev: TTM 设备
*/
void ttm_sys_man_init(struct ttm_device *bdev)
{
struct ttm_resource_manager *man = &bdev->sysman;
/*
* 初始化系统内存类型。
* 其他类型需要驱动/IOCTL 初始化。
*/
man->use_tt = true; // SYSTEM 需要 ttm_tt 管理物理页
man->func = &ttm_sys_manager_func;
ttm_resource_manager_init(man, bdev, 0); // size = 0(无限制)
ttm_set_driver_manager(bdev, TTM_PL_SYSTEM, man);
ttm_resource_manager_set_used(man, true);
}
关键点:
- 极简设计:只分配/释放结构体,没有额外逻辑
- use_tt = true:SYSTEM 内存需要通过 ttm_tt 管理实际的物理页
- size = 0:表示无限制(实际受系统内存限制)
- start 无意义:SYSTEM 资源的 start 字段不使用
3.2 Range Manager:GTT 地址区间管理
3.2.1 设计哲学
GTT 内存的特点:
- 通过 GART/IOMMU 将系统内存映射到 GPU 地址空间
- 需要管理 GPU 地址区间(如 0x1000-0x2000)
- 物理页通过 ttm_tt 管理,Range Manager 只管理 GPU 虚拟地址
- 需要处理碎片、对齐要求、地址范围限制
使用 drm_mm:
- Linux DRM 子系统提供的通用地址区间管理器
- 基于红黑树,支持快速查找、插入、删除
- 支持多种分配模式(BEST_FIT、TOP_DOWN 等)
3.2.2 数据结构
/* drivers/gpu/drm/ttm/ttm_range_manager.c */
/**
* struct ttm_range_manager – GTT 地址区间管理器
* @manager: 嵌入的 ttm_resource_manager
* @mm: drm_mm 地址区间管理器 ★
* @lock: 保护 @mm 的自旋锁
*/
struct ttm_range_manager {
struct ttm_resource_manager manager; // 基类
struct drm_mm mm; // drm_mm 管理器 ★
spinlock_t lock; // 保护 mm 的锁
};
/**
* struct ttm_range_mgr_node – GTT 资源节点
* @base: 嵌入的 ttm_resource
* @mm_nodes: drm_mm_node 数组(通常只有 1 个元素)
*/
struct ttm_range_mgr_node {
struct ttm_resource base; // 基类
struct drm_mm_node mm_nodes[1]; // drm_mm 节点 ★
};
static inline struct ttm_range_manager *
to_range_manager(struct ttm_resource_manager *man)
{
return container_of(man, struct ttm_range_manager, manager);
}
static inline struct ttm_range_mgr_node *
to_ttm_range_mgr_node(struct ttm_resource *res)
{
return container_of(res, struct ttm_range_mgr_node, base);
}
层次关系:
[ttm_range_manager]
├─> manager (ttm_resource_manager 基类)
└─> mm (drm_mm 地址区间管理)
↓
[drm_mm_node] (红黑树节点)
├─> start: GPU 地址偏移
├─> size: 区间大小
└─> …
3.2.3 分配实现
/**
* ttm_range_man_alloc – 分配 GTT 地址区间
* @man: 资源管理器
* @bo: 目标 BO
* @place: 放置要求
* @res: 输出资源
*/
static int ttm_range_man_alloc(struct ttm_resource_manager *man,
struct ttm_buffer_object *bo,
const struct ttm_place *place,
struct ttm_resource **res)
{
struct ttm_range_manager *rman = to_range_manager(man);
struct ttm_range_mgr_node *node;
struct drm_mm *mm = &rman->mm;
enum drm_mm_insert_mode mode;
unsigned long lpfn;
int ret;
// 1. 确定地址范围
lpfn = place->lpfn;
if (!lpfn)
lpfn = man->size; // 默认到管理器末尾
// 2. 分配节点结构(包含 ttm_resource + drm_mm_node)
node = kzalloc(struct_size(node, mm_nodes, 1), GFP_KERNEL);
if (!node)
return –ENOMEM;
// 3. 确定分配模式
mode = DRM_MM_INSERT_BEST; // 默认:最佳适配
if (place->flags & TTM_PL_FLAG_TOPDOWN)
mode = DRM_MM_INSERT_HIGH; // 从高地址分配
// 4. 初始化 ttm_resource 基类
ttm_resource_init(bo, place, &node->base);
// 5. 从 drm_mm 分配地址区间 ★
spin_lock(&rman->lock);
ret = drm_mm_insert_node_in_range(
mm, // drm_mm 管理器
&node->mm_nodes[0], // 输出节点
PFN_UP(node->base.size), // 请求大小(页数)
bo->page_alignment, // 对齐要求
0, // color(未使用)
place->fpfn, // 起始地址
lpfn, // 结束地址
mode // 分配模式
);
spin_unlock(&rman->lock);
if (unlikely(ret)) {
// 分配失败,清理并返回
ttm_resource_fini(man, &node->base);
kfree(node);
return ret;
}
// 6. 设置资源的起始地址
node->base.start = node->mm_nodes[0].start; // GPU 地址偏移 ★
*res = &node->base;
return 0;
}
关键步骤:
3.2.4 释放实现
/**
* ttm_range_man_free – 释放 GTT 地址区间
* @man: 资源管理器
* @res: 要释放的资源
*/
static void ttm_range_man_free(struct ttm_resource_manager *man,
struct ttm_resource *res)
{
struct ttm_range_mgr_node *node = to_ttm_range_mgr_node(res);
struct ttm_range_manager *rman = to_range_manager(man);
// 1. 从 drm_mm 移除节点 ★
spin_lock(&rman->lock);
drm_mm_remove_node(&node->mm_nodes[0]);
spin_unlock(&rman->lock);
// 2. 清理 ttm_resource 基类(从 LRU 移除等)
ttm_resource_fini(man, res);
// 3. 释放节点结构
kfree(node);
}
关键步骤:
3.2.5 兼容性检查
/**
* ttm_range_man_compatible – 判断资源是否与放置要求兼容
* @man: 资源管理器
* @res: 现有资源
* @place: 放置要求
* @size: 检查的大小
*
* 返回: true 兼容(不需要迁移),false 不兼容(需要迁移)
*/
static bool ttm_range_man_compatible(struct ttm_resource_manager *man,
struct ttm_resource *res,
const struct ttm_place *place,
size_t size)
{
struct drm_mm_node *node = &to_ttm_range_mgr_node(res)->mm_nodes[0];
u32 num_pages = PFN_UP(size);
// 检查地址范围是否在 place 要求的范围内
if (node->start < place->fpfn || // 起始地址太低
(place->lpfn && (node->start + num_pages) > place->lpfn)) // 结束地址太高
return false;
return true;
}
使用场景:
// ttm_bo_validate() 中的逻辑
if (man->func->compatible(man, bo->resource, place, bo->base.size)) {
// 资源已在正确位置,无需迁移
return 0;
} else {
// 需要重新分配 + 迁移数据
ttm_bo_move(bo, new_place);
}
3.2.6 相交性检查
/**
* ttm_range_man_intersects – 判断资源是否与放置要求相交
* @man: 资源管理器
* @res: 现有资源
* @place: 放置要求
* @size: 检查的大小
*
* 返回: true 相交(驱逐有意义),false 不相交(驱逐无意义)
*/
static bool ttm_range_man_intersects(struct ttm_resource_manager *man,
struct ttm_resource *res,
const struct ttm_place *place,
size_t size)
{
struct drm_mm_node *node = &to_ttm_range_mgr_node(res)->mm_nodes[0];
u32 num_pages = PFN_UP(size);
// 检查是否不相交
if (place->fpfn >= (node->start + num_pages) || // place 在资源右侧
(place->lpfn && place->lpfn <= node->start)) // place 在资源左侧
return false;
return true; // 相交
}
使用场景:
// Eviction 逻辑
list_for_each_entry(res, &man->lru[priority], lru) {
if (!man->func->intersects(man, res, place, size)) {
// 该资源与目标地址不相交,驱逐它无法释放有用空间
continue;
}
// 驱逐该 BO
ttm_bo_evict(res->bo);
}
图示说明:
GPU 地址空间:
[———— man->size ————]
0 max
情况 1:相交(intersects = true)
place: [—-需求—-]
res: [–现有–]
↑ 相交,驱逐有意义
情况 2:不相交(intersects = false)
place: [—-需求—-]
res: [–现有–]
↑ 不相交,驱逐无意义
3.3 VRAM Manager:Buddy Allocator(AMD 驱动实现)
3.3.1 设计哲学
VRAM 内存的特点:
- 容量有限且昂贵(如 8GB/16GB)
- 需要高效管理碎片(避免浪费)
- 可能需要连续分配(某些硬件要求)
- 可能有可见/不可见 VRAM 之分(PCIe BAR 限制)
Buddy Allocator 优势:
- 高效管理碎片:2 的幂次大小分配
- 支持快速合并(相邻空闲块)
- 支持连续分配
- 基于 drm_buddy(内核 DRM 子系统提供)
3.3.2 数据结构
/* drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c */
/**
* struct amdgpu_vram_mgr – VRAM 资源管理器
* @manager: 嵌入的 ttm_resource_manager
* @mm: drm_buddy 管理器 ★
* @lock: 保护 @mm 的互斥锁
* @vis_usage: 可见 VRAM 的使用量 ★
* @reserved_pages: 已保留的页列表
* @reservations_pending: 等待保留的列表
* @allocated_vres_list: 已分配的资源列表(调试用)
*/
struct amdgpu_vram_mgr {
struct ttm_resource_manager manager; // 基类
struct drm_buddy mm; // Buddy 管理器 ★
struct mutex lock; // 互斥锁(不同于 Range Manager 的自旋锁)
atomic64_t vis_usage; // 可见 VRAM 使用量
struct list_head reserved_pages; // 保留页列表
struct list_head reservations_pending; // 待保留列表
struct list_head allocated_vres_list; // 已分配资源列表(调试)
};
/**
* struct amdgpu_vram_mgr_resource – VRAM 资源节点
* @base: 嵌入的 ttm_resource
* @blocks: drm_buddy_block 链表 ★
* @flags: 分配标志(TOPDOWN、CONTIGUOUS 等)
* @task: 分配该资源的任务信息(调试用)
* @vres_node: 链接到 allocated_vres_list
*/
struct amdgpu_vram_mgr_resource {
struct ttm_resource base; // 基类
struct list_head blocks; // Buddy 块链表 ★
unsigned long flags; // 分配标志
struct task_info task; // 调试信息
struct list_head vres_node; // 链表节点
};
层次关系:
[amdgpu_vram_mgr]
├─> manager (ttm_resource_manager 基类)
└─> mm (drm_buddy Buddy 管理器)
↓
[drm_buddy_block] (Buddy 块,可能有多个)
├─> offset: VRAM 偏移
├─> size: 块大小(2 的幂次)
└─> link: 链接到 vres->blocks
与 Range Manager 的区别:
| 分配器 | drm_mm(红黑树) | drm_buddy(Buddy) |
| 资源节点 | 1 个 drm_mm_node | 多个 drm_buddy_block |
| 碎片管理 | 简单(首次/最佳适配) | 高效(2 的幂次 + 合并) |
| 连续分配 | 不保证 | 支持(CONTIGUOUS 标志) |
| 锁类型 | 自旋锁 | 互斥锁 |
3.3.3 分配实现(简化版)
/**
* amdgpu_vram_mgr_new – 分配 VRAM 资源
* @man: 资源管理器
* @tbo: 目标 BO
* @place: 放置要求
* @res: 输出资源
*/
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_device *adev = to_amdgpu_device(mgr);
struct amdgpu_bo *bo = ttm_to_amdgpu_bo(tbo);
struct amdgpu_vram_mgr_resource *vres;
struct drm_buddy *mm = &mgr->mm;
u64 size, lpfn, fpfn;
unsigned long pages_per_block;
int r;
// 1. 确定地址范围
lpfn = (u64)place->lpfn << PAGE_SHIFT;
if (!lpfn || lpfn > man->size)
lpfn = man->size;
fpfn = (u64)place->fpfn << PAGE_SHIFT;
// 2. 分配资源节点
vres = kzalloc(sizeof(*vres), GFP_KERNEL);
if (!vres)
return –ENOMEM;
ttm_resource_init(tbo, place, &vres->base);
INIT_LIST_HEAD(&vres->blocks);
// 3. 确定分配标志
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; // 连续分配 ★
// 4. 确定块大小(用于大页支持)
if (bo->flags & AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS) {
pages_per_block = ~0ul; // 整个对象作为一个块
} else {
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
pages_per_block = HPAGE_PMD_NR; // 2MB 大页
#else
pages_per_block = 2UL << (20UL – PAGE_SHIFT); // 默认 2MB
#endif
pages_per_block = max_t(u32, pages_per_block, tbo->page_alignment);
}
// 5. 从 Buddy 分配块 ★
mutex_lock(&mgr->lock);
size = vres->base.size;
while (size) {
struct drm_buddy_block *block;
unsigned long num_pages;
// 计算本次分配的页数
num_pages = min_t(u64, size >> PAGE_SHIFT, pages_per_block);
// 从 Buddy 分配
r = drm_buddy_alloc_blocks(mm,
fpfn, // 起始地址
lpfn, // 结束地址
num_pages << PAGE_SHIFT, // 大小
mm->chunk_size, // 最小块
&vres->blocks, // 输出链表
vres->flags); // 标志
if (r)
goto error_free_blocks;
size -= num_pages << PAGE_SHIFT;
fpfn += num_pages << PAGE_SHIFT;
}
mutex_unlock(&mgr->lock);
// 6. 设置资源的起始地址(第一个块的偏移)
struct drm_buddy_block *block = amdgpu_vram_mgr_first_block(&vres->blocks);
vres->base.start = amdgpu_vram_mgr_block_start(block); // VRAM 偏移 ★
// 7. 更新可见 VRAM 使用量
u64 vis_usage = amdgpu_vram_mgr_vis_size(adev, block);
atomic64_add(vis_usage, &mgr->vis_usage);
*res = &vres->base;
return 0;
error_free_blocks:
// 释放已分配的块
drm_buddy_free_list(mm, &vres->blocks);
mutex_unlock(&mgr->lock);
ttm_resource_fini(man, &vres->base);
kfree(vres);
return r;
}
关键步骤:
连续分配 vs 分散分配:
分散分配(默认):
VRAM: [块1: 2MB][块2: 2MB][块3: 1MB]
↑ 可能不连续,但分配成功率高
连续分配(CONTIGUOUS 标志):
VRAM: [——单块: 5MB——]
↑ 必须连续,可能因碎片失败
3.3.4 释放实现
/**
* amdgpu_vram_mgr_del – 释放 VRAM 资源
* @man: 资源管理器
* @res: 要释放的资源
*/
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 amdgpu_device *adev = to_amdgpu_device(mgr);
struct drm_buddy *mm = &mgr->mm;
struct drm_buddy_block *block;
uint64_t vis_usage = 0;
mutex_lock(&mgr->lock);
// 1. 计算可见 VRAM 使用量
list_for_each_entry(block, &vres->blocks, link) {
vis_usage += amdgpu_vram_mgr_vis_size(adev, block);
}
// 2. 释放所有 Buddy 块 ★
drm_buddy_free_list(mm, &vres->blocks);
mutex_unlock(&mgr->lock);
// 3. 更新统计
atomic64_sub(vis_usage, &mgr->vis_usage);
// 4. 从已分配列表移除(调试)
list_del(&vres->vres_node);
// 5. 清理资源
ttm_resource_fini(man, res);
kfree(vres);
}
关键步骤:
4. 资源管理器的生命周期
4.1 初始化
/**
* 资源管理器初始化流程(以 AMD 驱动为例)
*/
// 1. 驱动初始化时
int amdgpu_ttm_init(struct amdgpu_device *adev)
{
struct ttm_device *bdev = &adev->mman.bdev;
int r;
// 初始化 TTM 设备
r = ttm_device_init(&adev->mman.bdev, &amdgpu_bo_driver,
adev->dev, adev->ddev.anon_inode->i_mapping,
adev->need_swiotlb, adev->need_dma32);
if (r)
return r;
// 2. 初始化 VRAM 管理器 ★
r = amdgpu_vram_mgr_init(adev);
if (r) {
DRM_ERROR("Failed initializing VRAM heap.\\n");
return r;
}
// 3. 初始化 GTT 管理器 ★
r = amdgpu_gtt_mgr_init(adev);
if (r) {
DRM_ERROR("Failed initializing GTT heap.\\n");
return r;
}
// 4. SYSTEM 管理器由 TTM 自动初始化
// ttm_device_init() 内部调用 ttm_sys_man_init()
return 0;
}
// VRAM 管理器初始化
int amdgpu_vram_mgr_init(struct amdgpu_device *adev)
{
struct amdgpu_vram_mgr *mgr = &adev->mman.vram_mgr;
struct ttm_resource_manager *man = &mgr->manager;
int ret;
// 1. 初始化 Buddy 管理器
ret = drm_buddy_init(&mgr->mm,
adev->gmc.real_vram_size, // VRAM 总大小
PAGE_SIZE); // 最小块大小
if (ret)
return ret;
// 2. 初始化锁和链表
mutex_init(&mgr->lock);
INIT_LIST_HEAD(&mgr->reservations_pending);
INIT_LIST_HEAD(&mgr->reserved_pages);
INIT_LIST_HEAD(&mgr->allocated_vres_list);
atomic64_set(&mgr->vis_usage, 0);
// 3. 设置函数表
man->func = &amdgpu_vram_mgr_func;
// 4. 初始化 ttm_resource_manager 基类
ttm_resource_manager_init(man, &adev->mman.bdev,
adev->gmc.real_vram_size);
// 5. 注册到 TTM 设备
ttm_set_driver_manager(&adev->mman.bdev, TTM_PL_VRAM, man);
// 6. 启用该内存域
ttm_resource_manager_set_used(man, true);
return 0;
}
// GTT 管理器初始化(使用内核提供的 Range Manager)
int amdgpu_gtt_mgr_init(struct amdgpu_device *adev)
{
struct ttm_resource_manager *man;
// 使用 TTM 内核提供的 Range Manager
man = ttm_range_man_init(&adev->mman.bdev, TTM_PL_TT,
false, // use_tt = false(稍后设为 true)
adev->gmc.gart_size >> PAGE_SHIFT); // GTT 大小
if (IS_ERR(man))
return PTR_ERR(man);
// GTT 需要 ttm_tt
man->use_tt = true;
return 0;
}
初始化顺序:
4.2 使用阶段
/**
* 资源分配流程(BO 创建时)
*/
// 用户空间创建 BO
DRM_IOCTL_AMDGPU_GEM_CREATE
↓
amdgpu_gem_create_ioctl()
↓
amdgpu_gem_object_create()
↓
ttm_bo_init_reserved()
↓
ttm_bo_validate() ← 验证并分配资源
↓
ttm_bo_mem_space() ← 尝试各个候选位置
↓
for (i = 0; i < placement->num_placement; i++) {
place = &placement->placement[i];
man = ttm_manager_type(bdev, place->mem_type); // 获取管理器 ★
if (!man || !ttm_resource_manager_used(man))
continue;
// 调用管理器的 alloc 函数 ★★
ret = man->func->alloc(man, bo, place, &res);
if (ret == 0) {
// 分配成功
bo->resource = res;
return 0;
}
if (ret == –ENOSPC) {
// 空间不足,触发 eviction
ret = ttm_bo_mem_evict_first(bdev, man, place, ctx);
if (ret == 0) {
// 驱逐成功,重试分配
ret = man->func->alloc(man, bo, place, &res);
}
}
}
// 所有候选位置都失败
return –ENOSPC;
关键交互:
4.3 清理阶段
/**
* 资源管理器清理流程
*/
// 驱动卸载时
void amdgpu_ttm_fini(struct amdgpu_device *adev)
{
// 1. 释放所有 BO(驱动确保)
// …
// 2. 清理 GTT 管理器
ttm_range_man_fini(&adev->mman.bdev, TTM_PL_TT);
// 3. 清理 VRAM 管理器
amdgpu_vram_mgr_fini(adev);
// 4. 清理 TTM 设备(自动清理 SYSTEM 管理器)
ttm_device_fini(&adev->mman.bdev);
}
// VRAM 管理器清理
void amdgpu_vram_mgr_fini(struct amdgpu_device *adev)
{
struct amdgpu_vram_mgr *mgr = &adev->mman.vram_mgr;
struct ttm_resource_manager *man = &mgr->manager;
// 1. 禁用管理器
ttm_resource_manager_set_used(man, false);
// 2. 注销管理器
ttm_set_driver_manager(&adev->mman.bdev, TTM_PL_VRAM, NULL);
// 3. 清理 Buddy 管理器
drm_buddy_fini(&mgr->mm);
// 4. 清理基类
ttm_resource_manager_fini(man);
}
清理顺序:
5. 核心 API 接口
5.1 分配资源
/**
* ttm_resource_alloc – 分配资源(统一入口)
* @bo: 目标 BO
* @place: 放置要求
* @res: 输出资源
*
* 返回: 0 成功,负数失败
*/
int ttm_resource_alloc(struct ttm_buffer_object *bo,
const struct ttm_place *place,
struct ttm_resource **res)
{
struct ttm_device *bdev = bo->bdev;
struct ttm_resource_manager *man;
int ret;
// 1. 获取对应的管理器
man = ttm_manager_type(bdev, place->mem_type);
if (!man || !ttm_resource_manager_used(man))
return –ENODEV;
// 2. 调用管理器的 alloc 函数 ★
ret = man->func->alloc(man, bo, place, res);
if (ret)
return ret;
// 3. 更新使用量统计
spin_lock(&bdev->lru_lock);
man->usage += (*res)->size;
spin_unlock(&bdev->lru_lock);
// 4. 添加到 LRU 链表
if (bo->priority < TTM_MAX_BO_PRIORITY)
list_add_tail(&(*res)->lru, &man->lru[bo->priority]);
return 0;
}
5.2 释放资源
/**
* ttm_resource_free – 释放资源(统一入口)
* @bo: BO
* @res: 要释放的资源
*/
void ttm_resource_free(struct ttm_buffer_object *bo,
struct ttm_resource **res)
{
struct ttm_resource_manager *man;
if (!*res)
return;
// 1. 获取管理器
man = ttm_manager_type(bo->bdev, (*res)->mem_type);
// 2. 从 LRU 移除
spin_lock(&bo->bdev->lru_lock);
list_del_init(&(*res)->lru);
man->usage -= (*res)->size;
spin_unlock(&bo->bdev->lru_lock);
// 3. 调用管理器的 free 函数 ★
man->func->free(man, *res);
*res = NULL;
}
5.3 查询使用量
/**
* ttm_resource_manager_usage – 查询管理器使用量
* @man: 资源管理器
*
* 返回: 已使用的字节数
*/
static inline uint64_t
ttm_resource_manager_usage(struct ttm_resource_manager *man)
{
uint64_t usage;
spin_lock(&man->bdev->lru_lock);
usage = man->usage;
spin_unlock(&man->bdev->lru_lock);
return usage;
}
/**
* ttm_resource_manager_avail – 查询可用空间
* @man: 资源管理器
*
* 返回: 可用的字节数
*/
static inline uint64_t
ttm_resource_manager_avail(struct ttm_resource_manager *man)
{
uint64_t usage = ttm_resource_manager_usage(man);
if (man->size > usage)
return man->size – usage;
return 0;
}
5.4 启用/禁用管理器
/**
* ttm_resource_manager_set_used – 启用/禁用管理器
* @man: 资源管理器
* @used: true 启用,false 禁用
*/
void ttm_resource_manager_set_used(struct ttm_resource_manager *man,
bool used)
{
man->use_type = used;
}
/**
* ttm_resource_manager_used – 查询管理器是否启用
* @man: 资源管理器
*/
static inline bool
ttm_resource_manager_used(struct ttm_resource_manager *man)
{
return man->use_type;
}
6. 实际案例分析
案例 1:VRAM 分配流程完整追踪
场景:应用创建 8MB 渲染目标,优先 VRAM。
// 1. 用户空间调用
struct drm_amdgpu_gem_create args = {
.in.bo_size = 8 * 1024 * 1024, // 8MB
.in.domains = AMDGPU_GEM_DOMAIN_VRAM,
.in.domain_flags = AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED,
};
ioctl(fd, DRM_IOCTL_AMDGPU_GEM_CREATE, &args);
// 2. 内核空间:amdgpu_gem_create_ioctl()
int amdgpu_gem_create_ioctl(struct drm_device *dev, void *data,
struct drm_file *filp)
{
struct drm_amdgpu_gem_create *args = data;
struct ttm_place places[2];
struct ttm_placement placement;
// 设置放置策略:优先 VRAM,次选 GTT
places[0].mem_type = TTM_PL_VRAM;
places[0].flags = TTM_PL_FLAG_WC;
places[1].mem_type = TTM_PL_TT;
places[1].flags = TTM_PL_FLAG_CACHED;
placement.num_placement = 2;
placement.placement = places;
// 创建 BO
return amdgpu_gem_object_create(adev, args->in.bo_size,
&placement, ...);
}
// 3. ttm_bo_validate() → ttm_bo_mem_space()
int ttm_bo_mem_space(struct ttm_buffer_object *bo,
struct ttm_placement *placement,
struct ttm_resource **res,
struct ttm_operation_ctx *ctx)
{
struct ttm_device *bdev = bo->bdev;
int ret;
// 尝试 VRAM
struct ttm_place *place = &placement->placement[0]; // VRAM
struct ttm_resource_manager *man = ttm_manager_type(bdev, TTM_PL_VRAM);
// 调用 VRAM 管理器的 alloc ★
ret = man->func->alloc(man, bo, place, res);
if (ret == –ENOSPC) {
// VRAM 满了,触发 eviction
pr_info("VRAM full, triggering eviction\\n");
ret = ttm_bo_mem_evict_first(bdev, man, place, ctx);
if (ret == 0) {
// 驱逐成功,重试
ret = man->func->alloc(man, bo, place, res);
}
}
if (ret == 0) {
pr_info("BO allocated in VRAM at 0x%lx, size %lu\\n",
(*res)->start, (*res)->size);
return 0;
}
// VRAM 失败,尝试 GTT
place = &placement->placement[1]; // GTT
man = ttm_manager_type(bdev, TTM_PL_TT);
ret = man->func->alloc(man, bo, place, res);
if (ret == 0) {
pr_info("BO allocated in GTT at 0x%lx\\n", (*res)->start);
return 0;
}
return –ENOSPC;
}
// 4. amdgpu_vram_mgr_new() 执行实际分配
static int amdgpu_vram_mgr_new(...)
{
struct amdgpu_vram_mgr *mgr = to_vram_mgr(man);
struct drm_buddy *mm = &mgr->mm;
struct amdgpu_vram_mgr_resource *vres;
// 分配资源节点
vres = kzalloc(sizeof(*vres), GFP_KERNEL);
ttm_resource_init(bo, place, &vres->base);
INIT_LIST_HEAD(&vres->blocks);
// 从 Buddy 分配(8MB = 4 个 2MB 块)
mutex_lock(&mgr->lock);
u64 size = 8 * 1024 * 1024;
u64 pages_per_block = 2 * 1024 * 1024 >> PAGE_SHIFT; // 512 页
for (int i = 0; i < 4; i++) { // 4 次分配
ret = drm_buddy_alloc_blocks(mm,
0, // fpfn
man->size, // lpfn
2 << 20, // 2MB
PAGE_SIZE, // 最小块
&vres->blocks,
DRM_BUDDY_TOPDOWN_ALLOCATION);
if (ret)
goto error;
}
mutex_unlock(&mgr->lock);
// 设置起始地址
struct drm_buddy_block *first = amdgpu_vram_mgr_first_block(&vres->blocks);
vres->base.start = amdgpu_vram_mgr_block_start(first);
// 输出分配信息
pr_info("VRAM allocation:\\n");
list_for_each_entry(block, &vres->blocks, link) {
pr_info(" Block: offset 0x%llx, size %llu KB\\n",
amdgpu_vram_mgr_block_start(block),
amdgpu_vram_mgr_block_size(block) >> 10);
}
*res = &vres->base;
return 0;
}
输出示例:
VRAM allocation:
Block: offset 0x80000000, size 2048 KB
Block: offset 0x80200000, size 2048 KB
Block: offset 0x80400000, size 2048 KB
Block: offset 0x80600000, size 2048 KB
BO allocated in VRAM at 0x80000000, size 8388608
案例 2:GTT 地址区间碎片处理
场景:GTT 空间碎片化,新 BO 分配失败。
// 初始状态:GTT 256MB,已分配 200MB(碎片化)
GTT 地址空间:
[====已用===][空10MB][==已用==][空20MB][====已用====][空30MB][==已用==]
0 100 110 150 170 220 250 256MB
// 请求分配 32MB 连续空间
struct ttm_place place = {
.fpfn = 0,
.lpfn = 0, // 整个 GTT
.mem_type = TTM_PL_TT,
.flags = 0,
};
// ttm_range_man_alloc() 尝试分配
int ttm_range_man_alloc(...)
{
struct ttm_range_manager *rman = to_range_manager(man);
struct drm_mm *mm = &rman->mm;
// 尝试在 drm_mm 中查找 32MB 空闲区间
spin_lock(&rman->lock);
ret = drm_mm_insert_node_in_range(mm, &node->mm_nodes[0],
PFN_UP(32 << 20), // 8192 页
bo->page_alignment,
0, // color
0, // fpfn
man->size >> PAGE_SHIFT, // lpfn
DRM_MM_INSERT_BEST);
spin_unlock(&rman->lock);
if (ret == –ENOSPC) {
pr_info("GTT fragmented, no 32MB contiguous space\\n");
pr_info("Available fragments: 10MB, 20MB, 30MB\\n");
return –ENOSPC;
}
}
// 触发 eviction
ttm_bo_mem_evict_first() {
// 从 LRU 找到可驱逐的 BO(优先级 2,最久未使用)
list_for_each_entry(res, &man->lru[2], lru) {
if (man->func->intersects(man, res, place, 32 << 20)) {
// 该 BO 占用的地址区间与目标相交
bo = res->bo;
// 驱逐到 SYSTEM
ttm_bo_evict(bo);
break;
}
}
}
// 驱逐后状态:
GTT 地址空间:
[====已用===][空10MB][==已用==][—————空52MB—————][==已用==]
0 100 110 150 220 256MB
↑ 合并后满足 32MB 需求
// 重试分配成功
ret = drm_mm_insert_node_in_range(...); // 返回 0
pr_info("BO allocated at GTT offset 0x%lx\\n", node->mm_nodes[0].start);
关键点:
- drm_mm 自动查找最佳适配空闲区间
- 碎片化导致分配失败(没有足够大的连续空间)
- Eviction 后 drm_mm 自动合并相邻空闲区间
- 重试分配成功
案例 3:VRAM 可见区域限制
场景:PCIe BAR 限制,只有 256MB VRAM 可被 CPU 访问。
// AMD GPU 配置:
// – 总 VRAM: 8GB
// – 可见 VRAM (BAR): 256MB (0x0 – 0x10000000)
// – 不可见 VRAM: 7.75GB (0x10000000 – 0x200000000)
struct amdgpu_device *adev;
adev->gmc.real_vram_size = 8ULL << 30; // 8GB
adev->gmc.visible_vram_size = 256ULL << 20; // 256MB
// 应用请求 CPU 可访问的 BO (用于 mmap)
struct drm_amdgpu_gem_create args = {
.in.bo_size = 4 << 20, // 4MB
.in.domains = AMDGPU_GEM_DOMAIN_VRAM,
.in.domain_flags = AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED, // 关键标志 ★
};
// amdgpu_gem_create_ioctl()
if (args->in.domain_flags & AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED) {
// 限制在可见 VRAM 范围内
places[0].fpfn = 0;
places[0].lpfn = adev->gmc.visible_vram_size >> PAGE_SHIFT; // 256MB 边界 ★
places[0].mem_type = TTM_PL_VRAM;
pr_info("Requesting CPU-accessible VRAM: range [0, 0x%llx]\\n",
adev->gmc.visible_vram_size);
}
// amdgpu_vram_mgr_new()
static int amdgpu_vram_mgr_new(...)
{
u64 lpfn = (u64)place->lpfn << PAGE_SHIFT; // 0x10000000 (256MB)
// 从 Buddy 分配(限制在可见区域)
ret = drm_buddy_alloc_blocks(mm,
0, // fpfn = 0
lpfn, // lpfn = 256MB ★
4 << 20, // 4MB
PAGE_SIZE,
&vres->blocks,
vres->flags);
if (ret == –ENOSPC) {
pr_info("Visible VRAM full (256MB all used)\\n");
pr_info("Total VRAM usage: %llu MB (out of 8GB)\\n",
ttm_resource_manager_usage(man) >> 20);
pr_info("Visible VRAM usage: %llu MB (out of 256MB)\\n",
atomic64_read(&mgr->vis_usage) >> 20);
// 可能触发驱逐(只驱逐可见区域的 BO)
return –ENOSPC;
}
// 成功分配在可见区域
struct drm_buddy_block *block = amdgpu_vram_mgr_first_block(&vres->blocks);
u64 offset = amdgpu_vram_mgr_block_start(block);
WARN_ON(offset >= adev->gmc.visible_vram_size); // 断言在可见区域内
// 更新可见 VRAM 统计
atomic64_add(4 << 20, &mgr->vis_usage);
pr_info("BO allocated in visible VRAM at offset 0x%llx\\n", offset);
}
// 用户 mmap 时可以正常访问
int amdgpu_gem_mmap_ioctl(...)
{
if (bo->tbo.resource->mem_type == TTM_PL_VRAM) {
u64 offset = bo->tbo.resource->start;
if (offset >= adev->gmc.visible_vram_size) {
// 不可见 VRAM,禁止 mmap
pr_err("BO at 0x%llx is in invisible VRAM, cannot mmap\\n", offset);
return –EINVAL;
}
// 可见 VRAM,允许 mmap
vma->vm_pgoff += (adev->gmc.aper_base + offset) >> PAGE_SHIFT;
}
}
关键点:
- fpfn/lpfn 限制:lpfn = 256MB,强制分配在可见区域
- 独立统计:vis_usage 追踪可见 VRAM 使用量
- mmap 检查:只有可见 VRAM 的 BO 才能被 CPU 访问
- Eviction 优化:可以选择性驱逐可见/不可见区域的 BO
7. 常见问题解答
Q1:为什么 Range Manager 使用自旋锁,而 VRAM Manager 使用互斥锁?
回答:
Range Manager (GTT) – 自旋锁:
struct ttm_range_manager {
spinlock_t lock; // 自旋锁 ★
struct drm_mm mm;
};
原因:
- 操作快速:drm_mm 操作(红黑树插入/删除)通常在微秒级完成
- 无睡眠操作:drm_mm 不涉及内存分配、IO 等可能睡眠的操作
- 减少延迟:自旋锁避免了进程切换的开销
VRAM Manager (Buddy) – 互斥锁:
struct amdgpu_vram_mgr {
struct mutex lock; // 互斥锁 ★
struct drm_buddy mm;
};
原因:
- 操作复杂:Buddy 分配可能需要多次分裂/合并,耗时较长
- 可能睡眠:drm_buddy 可能分配内存(如 kzalloc(GFP_KERNEL))
- 避免死锁:持有互斥锁时可以安全调用其他可睡眠函数
对比表格:
| 临界区时长 | < 10 µs | 可能 > 100 µs |
| 是否可睡眠 | ❌ 否 | ✅ 是 |
| 中断上下文 | ✅ 可用 | ❌ 不可用 |
| 开销 | 低(忙等待) | 高(进程切换) |
| 适用场景 | 快速操作、中断处理 | 复杂操作、可能睡眠 |
最佳实践:
- 如果临界区 < 100 µs 且不睡眠 → 自旋锁
- 如果临界区 > 100 µs 或可能睡眠 → 互斥锁
Q2:SYSTEM 管理器为什么几乎没有管理逻辑?
回答:
SYSTEM 内存的特殊性:
// VRAM/GTT: 需要管理 GPU 地址空间
VRAM: [0x0 – 0x200000000] (8GB 固定范围)
GTT: [0x0 – 0x100000000] (4GB GART 地址空间)
// SYSTEM: 无固定地址空间
SYSTEM: 直接使用 alloc_pages() 分配,地址由内核 MM 决定
→ 不需要 TTM 管理地址
// VRAM BO:
bo->resource->mem_type = TTM_PL_VRAM;
bo->resource->start = 0x80000000; // VRAM 偏移 ★
bo->ttm = NULL; // 不需要 ttm_tt
// SYSTEM BO:
bo->resource->mem_type = TTM_PL_SYSTEM;
bo->resource->start = 0; // 无意义 ★
bo->ttm = ttm_tt_create(); // 通过 ttm_tt 管理物理页 ★
bo->ttm->pages[] = { page1, page2, ... };
// VRAM/GTT: TTM 负责处理 -ENOSPC(触发 eviction)
ret = man->func->alloc(...);
if (ret == –ENOSPC) {
ttm_bo_mem_evict_first(); // TTM 驱逐逻辑
}
// SYSTEM: 分配失败由内核 OOM killer 处理
ttm_tt_populate() {
pages[i] = alloc_page(GFP_KERNEL); // 失败时内核自动处理
}
// VRAM: Buddy 管理碎片
// GTT: drm_mm 管理碎片
// SYSTEM: 内核页分配器自动处理碎片
// 每个页独立,不需要连续地址空间
ttm_sys_manager 的真正作用:
- 统一接口:提供与 VRAM/GTT 一致的 alloc / free 接口
- 资源统计:追踪 SYSTEM 内存使用量(man->usage)
- LRU 管理:支持 SYSTEM BO 的 LRU 排序(用于 swap)
Q3:compatible 和 intersects 函数有什么区别?
回答:
compatible(兼容性检查):
// 用途:判断是否需要迁移
bool (*compatible)(struct ttm_resource_manager *man,
struct ttm_resource *res,
const struct ttm_place *place,
size_t size);
使用场景:
// ttm_bo_validate() 中
if (bo->resource &&
bo->resource->mem_type == place->mem_type) {
// 已在目标内存域,检查是否兼容
if (man->func->compatible(man, bo->resource, place, bo->base.size)) {
// 兼容!无需迁移
return 0;
}
// 不兼容,需要重新分配
ttm_bo_move(bo, new_place);
}
例子:
// 场景:BO 在 GTT 0x1000-0x2000,请求范围 [0x0, 0x10000]
struct ttm_resource *res = bo->resource; // start = 0x1000
struct ttm_place place = { .fpfn = 0, .lpfn = 0x10000 };
bool result = ttm_range_man_compatible(man, res, &place, 4096);
// 检查:res->start (0x1000) >= place.fpfn (0) ✓
// res->start + size (0x2000) <= place.lpfn (0x10000) ✓
// → result = true(兼容,无需迁移)
// 场景 2:请求范围 [0x0, 0x800]
place.lpfn = 0x800;
result = ttm_range_man_compatible(man, res, &place, 4096);
// 检查:res->start (0x1000) >= place.fpfn (0) ✓
// res->start + size (0x2000) <= place.lpfn (0x800) ✗
// → result = false(不兼容,需要迁移到 [0, 0x800] 范围内)
intersects(相交性检查):
// 用途:判断驱逐是否有意义
bool (*intersects)(struct ttm_resource_manager *man,
struct ttm_resource *res,
const struct ttm_place *place,
size_t size);
使用场景:
// Eviction 逻辑
list_for_each_entry(res, &man->lru[priority], lru) {
if (!man->func->intersects(man, res, place, size)) {
// 不相交,驱逐该 BO 无法释放目标范围的空间
continue;
}
// 相交,驱逐该 BO 可能有帮助
ttm_bo_evict(res->bo);
}
例子:
// 场景:需要在 [0x1000, 0x2000] 分配 4KB
struct ttm_place place = { .fpfn = 0x1000, .lpfn = 0x2000 };
// BO1 在 [0x1500, 0x2500]
struct ttm_resource *res1; // start = 0x1500
bool result = ttm_range_man_intersects(man, res1, &place, 4096);
// 检查:place.fpfn (0x1000) < res1->end (0x2500) ✓
// place.lpfn (0x2000) > res1->start (0x1500) ✓
// → result = true(相交,驱逐 BO1 可能有帮助)
// BO2 在 [0x3000, 0x4000]
struct ttm_resource *res2; // start = 0x3000
result = ttm_range_man_intersects(man, res2, &place, 4096);
// 检查:place.fpfn (0x1000) >= res2->end (0x4000) ✗
// → result = false(不相交,驱逐 BO2 没有意义)
对比表格:
| 检查对象 | 当前 BO 的资源 | LRU 链表中的其他 BO |
| 目的 | 判断是否需要迁移 | 判断驱逐是否有意义 |
| 返回 true | 资源兼容,无需迁移 | 资源相交,驱逐有帮助 |
| 返回 false | 资源不兼容,需要迁移 | 资源不相交,驱逐无意义 |
| 调用时机 | ttm_bo_validate() 验证阶段 | ttm_bo_mem_evict_first() 驱逐阶段 |
图示:
compatible:
BO 已有资源 place 要求
[—res—] [—–allowed—–]
↑ 检查 res 是否在 allowed 范围内
intersects:
需求范围 已有 BO
[–place–] [–res–]
↑ 检查 res 是否与 place 重叠
Q4:为什么 VRAM BO 不需要 ttm_tt,而 GTT BO 需要?
回答:
根本原因:物理内存的来源和访问方式不同。
VRAM BO:
// 1. 物理位置
VRAM: GPU 板载内存,物理地址固定(如 0x80000000)
// 2. 资源描述
bo->resource->mem_type = TTM_PL_VRAM;
bo->resource->start = 0x80000000; // VRAM 物理偏移 ★
bo->ttm = NULL; // 不需要 ttm_tt ★
// 3. GPU 访问
GPU 直接访问 VRAM:
GPU 页表: VA 0x1000 → VRAM PA 0x80000000
硬件直接访问板载内存
// 4. CPU 访问(mmap)
CPU 通过 PCIe BAR 映射 VRAM:
vm_insert_pfn_prot(vma, va, (0x80000000 >> PAGE_SHIFT), WC);
CPU 通过 PCIe 读写 VRAM
GTT BO:
// 1. 物理位置
GTT: 系统内存(如 RAM 0x12345000、0x23456000 等)
// 2. 资源描述
bo->resource->mem_type = TTM_PL_TT;
bo->resource->start = 0x10000; // GART 地址空间偏移 ★
bo->ttm = ttm_tt_create(); // 需要 ttm_tt 管理物理页 ★
bo->ttm->pages[] = { page1, page2, ... }; // 实际物理页
bo->ttm->dma_address[] = { 0x12345000, 0x23456000, ... }; // DMA 地址
// 3. GPU 访问(需要 GART/IOMMU 转换)
GPU 访问 GTT:
GPU 页表: VA 0x1000 → GART 0x10000
GART 页表: GART 0x10000 → PA 0x12345000 ★
硬件通过 GART/IOMMU 访问系统内存
// 4. CPU 访问(mmap)
CPU 直接访问系统内存:
vm_insert_page(vma, va, bo->ttm->pages[i]);
CPU 无需通过 PCIe,直接访问 RAM
核心差异:
| 物理内存 | GPU 板载内存(固定地址) | 系统内存(分散页) |
| 地址转换 | 不需要(直接物理地址) | 需要(GART/IOMMU 转换) |
| ttm_tt | ❌ 不需要 | ✅ 需要 |
| resource->start | VRAM 物理偏移 | GART 虚拟地址 |
| GPU 访问路径 | GPU → VRAM | GPU → GART → IOMMU → RAM |
| CPU 访问路径 | CPU → PCIe → VRAM | CPU → RAM |
ttm_tt 的真正作用:
迁移时的变化:
// VRAM → GTT 迁移
ttm_bo_move_to_gtt(bo) {
// 1. 创建 ttm_tt(之前没有)
ttm_tt_create(bo, true);
ttm_tt_populate(bo->bdev, bo->ttm, ctx); // 分配物理页
// 2. 拷贝数据:VRAM → 系统内存
memcpy_from_vram_to_pages(bo);
// 3. 绑定 GTT
ttm_tt_bind(bo->bdev, bo->ttm, new_res); // 填充 GART 页表
// 4. 切换 resource
bo->resource = new_res; // mem_type = TTM_PL_TT
}
// GTT → VRAM 迁移
ttm_bo_move_to_vram(bo) {
// 1. 拷贝数据:系统内存 → VRAM
memcpy_from_pages_to_vram(bo);
// 2. 解绑 GTT
ttm_tt_unbind(bo->bdev, bo->ttm);
// 3. 销毁 ttm_tt(不再需要)
ttm_tt_destroy(bo->bdev, bo->ttm);
bo->ttm = NULL;
// 4. 切换 resource
bo->resource = new_res; // mem_type = TTM_PL_VRAM
}
Q5:资源管理器的 usage 统计如何保证准确性?
回答:
usage 统计的挑战:
- 多个 CPU 核心并发分配/释放
- 需要原子更新且高效
- 需要与 LRU 管理同步
TTM 的解决方案:
1. 使用单一锁保护(bdev->lru_lock):
struct ttm_device {
spinlock_t lru_lock; // 保护 LRU 和 usage ★
};
struct ttm_resource_manager {
uint64_t usage; // 受 bdev->lru_lock 保护 ★
struct list_head lru[4]; // 也受 bdev->lru_lock 保护
};
2. alloc 时更新:
int ttm_resource_alloc(...)
{
// 1. 调用管理器的 alloc(不持有锁)
ret = man->func->alloc(man, bo, place, res);
if (ret)
return ret;
// 2. 持锁更新 usage 和 LRU ★
spin_lock(&bdev->lru_lock);
man->usage += (*res)->size; // 增加使用量
list_add_tail(&(*res)->lru, &man->lru[bo->priority]); // 添加到 LRU
spin_unlock(&bdev->lru_lock);
return 0;
}
3. free 时更新:
void ttm_resource_free(...)
{
// 1. 持锁更新 usage 和 LRU ★
spin_lock(&bdev->lru_lock);
list_del_init(&(*res)->lru); // 从 LRU 移除
man->usage -= (*res)->size; // 减少使用量
spin_unlock(&bdev->lru_lock);
// 2. 调用管理器的 free(不持有锁)
man->func->free(man, *res);
}
4. 锁的嵌套规则:
// 正确的锁顺序:
1. man->lock (管理器内部锁,如 rman->lock)
2. bdev->lru_lock (TTM 全局锁)
// 示例:Range Manager alloc
ttm_range_man_alloc() {
spin_lock(&rman->lock); // 1. 先获取管理器锁
drm_mm_insert_node(...);
spin_unlock(&rman->lock);
// 返回后,ttm_resource_alloc() 会获取 bdev->lru_lock
}
// ❌ 错误的做法(会死锁):
spin_lock(&bdev->lru_lock);
spin_lock(&rman->lock); // 死锁!其他代码可能反向获取
5. 查询时的原子性:
uint64_t ttm_resource_manager_usage(struct ttm_resource_manager *man)
{
uint64_t usage;
spin_lock(&man->bdev->lru_lock);
usage = man->usage; // 原子读取 ★
spin_unlock(&man->bdev->lru_lock);
return usage;
}
6. 为什么不使用 atomic64_t?:
// 备选方案:使用 atomic64_t
struct ttm_resource_manager {
atomic64_t usage; // 原子变量
};
// 为什么 TTM 不这样做?
原因 1:需要同时更新 usage 和 LRU
→ 两个操作必须原子化,单独的 atomic64_t 不够
原因 2:避免多个原子操作
atomic64_add(&man->usage, size);
spin_lock(&bdev->lru_lock);
list_add_tail(...);
spin_unlock(&bdev->lru_lock);
→ 在两个操作之间,usage 和 LRU 可能不一致
原因 3:统一锁策略
→ 所有 LRU 相关操作都用同一把锁,简化设计
正确性保证:
- ✅ 原子性:usage 和 lru 在同一把锁保护下更新
- ✅ 一致性:usage 始终等于所有 lru 链表中资源的大小之和
- ✅ 无竞争:所有访问 usage 的代码都持有 bdev->lru_lock
8. 总结
核心要点
定位:ttm_resource_manager 是 TTM 对内存域的统一抽象
- 定义标准接口(ttm_resource_manager_func)
- 允许不同内存域使用不同的分配策略
- 管理 LRU 链表、usage 统计、eviction 支持
三种实现:
- SYSTEM Manager:极简(kzalloc/kfree)
- Range Manager:drm_mm 地址区间管理(GTT)
- VRAM Manager:drm_buddy Buddy 分配器(VRAM)
操作函数表:
- alloc/free:核心操作(必须实现)
- compatible:判断是否需要迁移(性能优化)
- intersects:判断驱逐是否有意义(eviction 优化)
- debug:调试信息(辅助功能)
关键字段:
- func:操作函数表(多态接口)
- use_type:是否启用
- use_tt:是否需要 ttm_tt
- size:管理的内存大小
- usage:当前使用量
- lru[4]:4 个优先级的 LRU 链表
锁与同步:
- 管理器内部锁(rman->lock / mgr->lock)
- TTM 全局锁(bdev->lru_lock)
- 锁顺序:管理器锁 → TTM 全局锁
记忆口诀
资源管理器统一抽象,三种实现各有所长
SYSTEM 极简 kzalloc,Range Manager drm_mm 管地址
VRAM Manager Buddy 强,碎片管理效率高
alloc/free 核心操作,compatible/intersects 优化驱逐
LRU 四级优先级,usage 统计保准确
use_tt 区分 VRAM/GTT,func 函数表多态接口
与前文的联系
TTM 架构(第一篇)
↓
[ttm_buffer_object] ← 第二篇:核心对象
├─> resource ──────> [ttm_resource] ← 第三篇:物理资源
│ ↓
│ 由 [ttm_resource_manager] 分配 ← 本文(第四篇)★
│ ↓
│ 具体实现:
│ ├─ System Manager (kzalloc)
│ ├─ Range Manager (drm_mm)
│ └─ VRAM Manager (drm_buddy)
│
├─> ttm ───────────> [ttm_tt] ← 下一篇(第五篇)
└─> bdev ──────────> [ttm_device] ← 已介绍
