欢迎光临
我们一直在努力

第四章:TTM分析: 4.3 ttm_resource--显存资源分配的核心抽象

1. 引言:为什么需要 ttm_resource?

在上一篇文章中,我们分析了 TTM 的核心设计目标:

  • 统一管理异构内存域(VRAM、GTT、SYSTEM)
  • 显存动态调度与超配(eviction 机制)
  • GPU 虚拟地址与页表管理

那么问题来了:如何统一描述这三种完全不同的内存的分配结果?

  • VRAM:GPU 芯片上的高速显存,需要用 Buddy 分配器管理物理块
  • GTT:GPU 可访问的系统内存,需要管理 GPU 侧的虚拟地址空间
  • SYSTEM:纯系统内存,由页分配器管理,GPU 通过 DMA 访问

这三种内存的分配方式、地址空间、访问特性都完全不同,但 TTM 必须提供统一的接口来管理它们。这就是ttm_resource的职责,从该视角让我们认识下ttm_resource:

  • ttm_resource 是什么?—— 物理内存占用的凭证/描述符
  • 它解决什么问题?—— 统一描述不同类型内存的分配结果
  • 它如何与其他结构体协作?—— 作为 BO 与物理内存之间的桥梁

核心结论:

ttm_resource 是 TTM 对"任何类型的物理内存/地址空间分配结果"的统一抽象。

只要 BO 占用了某类内存/地址空间(不管是 VRAM、GTT、还是 SYSTEM),就必须有 ttm_resource 来描述这个"占用事实"。


2. ttm_resource 核心结构体详解

2.1 结构体定义剖析

/**
* struct ttm_resource
* Structure indicating the placement and space resources used by a
* buffer object.
*/

struct ttm_resource {
unsigned long start; // 起始地址/偏移
size_t size; // 资源大小
uint32_t mem_type; // 内存类型(VRAM/GTT/SYSTEM)
uint32_t placement; // 放置标志
struct ttm_bus_placement bus; // CPU 端总线映射信息
struct ttm_buffer_object *bo; // 反向指针指向所属 BO
struct ttm_lru_item lru; // LRU 链表节点
struct dmem_cgroup_pool_state *css; // cgroup 资源记账
};

2.2 字段详细解析

字段类型含义关键点
start unsigned long 资源起始位置 VRAM: 物理偏移(相对于显存基址)GTT: GTT 地址空间偏移SYSTEM: 无意义(通常为 0)
size size_t 资源大小(字节) 实际分配的物理内存/地址空间大小
mem_type uint32_t 内存域类型 TTM_PL_VRAM (0)TTM_PL_TT (1,即 GTT)TTM_PL_SYSTEM (2)
placement uint32_t 放置标志位 标记访问属性:- TTM_PL_FLAG_WC (Write-Combine)- TTM_PL_FLAG_UNCACHED- TTM_PL_FLAG_CACHED
bus struct ttm_bus_placement CPU 端映射信息 CPU mmap 时使用:- addr: 映射的虚拟地址- offset: 物理地址- is_iomem: 是否为 IO 内存- caching: 缓存属性
bo struct ttm_buffer_object * 反向引用 指向拥有这个资源的 BO注意: 弱引用,由 ttm_device::lru_lock 保护
lru struct ttm_lru_item LRU 节点 用于 eviction 时的 LRU 算法挂载到 ttm_resource_manager::lru 链表
css struct dmem_cgroup_pool_state * cgroup 资源记账 用于内存控制组(cgroup)资源统计

2.3 辅助结构:ttm_bus_placement

/**
* struct ttm_bus_placement
*
* @addr: mapped virtual address
* @offset: physical addr
* @is_iomem: is this io memory ?
* @caching: See enum ttm_caching
*
* Structure indicating the bus placement of an object.
*/

struct ttm_bus_placement {
void *addr; // CPU 端映射的虚拟地址
phys_addr_t offset; // 物理地址偏移
bool is_iomem; // 是否为 IO 内存(VRAM 为 true)
enum ttm_caching caching; // 缓存属性
};

使用场景:

  • CPU 通过 mmap 访问 BO 时,根据 bus 信息建立页表映射
  • VRAM:is_iomem=true,通过 IO 地址映射访问
  • GTT/SYSTEM:is_iomem=false,直接访问系统内存

3. ttm_resource 的生命周期

3.1 创建流程

用户分配 BO
↓
ttm_bo_init_reserved() / ttm_bo_validate()
↓
ttm_bo_mem_space() ← 选择合适的内存域
↓
ttm_resource_alloc() ← 分配 resource
↓
man->func->alloc() ← 调用具体管理器的分配函数
↓
├─ VRAM: ttm_buddy_man_alloc() → 返回 ttm_buddy_resource
├─ GTT: ttm_range_man_alloc() → 返回 ttm_range_mgr_node
└─ SYSTEM: ttm_sys_man_alloc() → 返回基础 ttm_resource
↓
bo->resource = 新分配的 resource

关键函数:

/**
* ttm_resource_alloc – 分配 TTM 资源
* @bo: 要分配资源的 buffer object
* @place: 放置要求(内存域、对齐、标志等)
* @res: 输出参数,返回分配的 resource
*
* 返回: 0 表示成功,-ENOSPC 表示空间不足,负数表示其他错误
*/

int ttm_resource_alloc(struct ttm_buffer_object *bo,
const struct ttm_place *place,
struct ttm_resource **res);

3.2 使用阶段

场景 1:BO 迁移时查询当前位置

struct ttm_resource *old_mem = bo->resource;
if (old_mem->mem_type == TTM_PL_VRAM) {
// 当前在 VRAM,需要迁移到 GTT
}

场景 2:CPU mmap 访问

// DRM mmap 处理函数中
struct ttm_resource *mem = bo->resource;
if (mem->bus.is_iomem) {
// VRAM,使用 IO 地址映射
vma->vm_pgoff += mem->bus.offset >> PAGE_SHIFT;
} else {
// GTT/SYSTEM,直接映射系统内存
}

场景 3:GPU 访问时填充页表

// GPU 页表更新(驱动特定代码)
struct ttm_resource *mem = bo->resource;
uint64_t gpu_addr = mem->start; // GPU 侧的起始地址

if (mem->mem_type == TTM_PL_VRAM) {
// 填充 GPU 页表,指向 VRAM 物理地址
update_gpu_page_table(gpu_addr, vram_phys_addr);
} else if (mem->mem_type == TTM_PL_TT) {
// 填充 GPU 页表,指向 GTT 映射的系统内存
update_gpu_page_table(gpu_addr, gtt_dma_addr);
}

3.3 销毁流程

BO 释放或迁移
↓
ttm_resource_free() ← 释放旧的 resource
↓
man->func->free() ← 调用管理器的释放函数
↓
├─ VRAM: ttm_buddy_man_free() → 归还 buddy 内存块
├─ GTT: ttm_range_man_free() → 释放 drm_mm 节点
└─ SYSTEM: ttm_sys_man_free() → 简单释放结构体
↓
bo->resource = NULL (或指向新的 resource)

关键函数:

/**
* ttm_resource_free – 释放 TTM 资源
* @bo: 拥有该资源的 buffer object
* @res: 要释放的 resource 指针的指针
*/

void ttm_resource_free(struct ttm_buffer_object *bo,
struct ttm_resource **res);


4. 不同内存域的 ttm_resource 实现

4.1 VRAM 场景:ttm_buddy_resource

定义(位于 ttm_buddy_manager.c):

/**
* struct ttm_buddy_resource – TTM Buddy 管理器的资源描述
* @base: 基础 ttm_resource
* @blocks: Buddy 分配的内存块链表
* @flags: 内存属性标志(如 TOPDOWN、CONTIGUOUS 等)
*/

struct ttm_buddy_resource {
struct ttm_resource base; // 继承自 ttm_resource
struct list_head blocks; // buddy 分配的内存块链表
unsigned long flags; // 内存属性标志
};

特点:

  • 使用 Buddy 分配器管理 VRAM 物理内存
  • blocks 链表记录分配的一个或多个物理内存块
  • base.start 通常是首个 block 的物理偏移
  • 支持连续分配(CONTIGUOUS)和从高地址分配(TOPDOWN)

分配流程:

ttm_buddy_man_alloc()
↓
ttm_buddy_alloc() ← Buddy 分配器核心算法
↓
分配一个或多个 buddy block
↓
将 block 链接到 ttm_buddy_resource::blocks
↓
设置 base.start = 首个 block 的偏移

4.2 GTT 场景:ttm_range_mgr_node

定义(位于 ttm_range_manager.c):

/**
* struct ttm_range_mgr_node – GTT 地址空间分配节点
* @base: 基础 ttm_resource
* @mm_nodes: 地址区间节点数组(支持碎片化分配)
*/

struct ttm_range_mgr_node {
struct ttm_resource base; // 继承自 ttm_resource
struct drm_mm_node mm_nodes[]; // 地址区间节点(柔性数组)
};

特点:

  • 使用 drm_mm 管理 GTT 地址空间(类似于 vmalloc 的地址分配)
  • mm_nodes 可能包含多个节点(当 GTT 空间碎片化时)
  • base.start 是首个 mm_nodes 的起始偏移
  • GTT 是 GPU 侧的虚拟地址空间,实际物理页由 ttm_tt 管理

分配流程:

ttm_range_man_alloc()
↓
drm_mm_insert_node_generic() ← 在 GTT 地址空间中找空闲区域
↓
分配 ttm_range_mgr_node(可能包含多个 mm_nodes)
↓
设置 base.start = mm_nodes[0].start

关键理解:

GTT 分配的是 GPU 地址空间,不是物理内存!
物理页的分配和映射由 ttm_tt 负责,GTT 只是提供 GPU 侧的虚拟地址。

4.3 SYSTEM 场景:纯 ttm_resource

定义:

// 不需要继承,直接使用基础的 ttm_resource

特点:

  • 不需要地址空间分配(系统内存由 ttm_tt 的页池分配)
  • ttm_resource 仅作为占位符,记录:
    • mem_type = TTM_PL_SYSTEM
    • size = BO 大小
    • start 无实际意义(通常为 0)
  • 物理页管理完全由 ttm_tt 负责

分配流程:

ttm_sys_man_alloc()
↓
简单分配一个 ttm_resource 结构体
↓
设置 mem_type = TTM_PL_SYSTEM
设置 size = bo->base.size
设置 start = 0

4.4 对比总结表

内存域具体类型管理方式start 含义额外字段物理页管理
VRAM ttm_buddy_resource Buddy 分配器 VRAM 物理偏移 blocks 链表 Buddy 内存块
GTT ttm_range_mgr_node drm_mm 区间管理 GTT 虚拟偏移 mm_nodes 数组 由 ttm_tt 管理
SYSTEM ttm_resource 页池分配 无意义(0) 无 由 ttm_tt 管理

记忆口诀:

  • VRAM 用 Buddy,物理块成链
  • GTT 用区间,虚拟地址段
  • SYSTEM 占位符,页表另外管

5. ttm_resource 与其他结构体的交互

5.1 与 ttm_buffer_object 的关系

/**
* struct ttm_buffer_object – TTM 缓冲区对象
*/

struct ttm_buffer_object {
struct drm_gem_object base; // 继承自 GEM

struct ttm_resource *resource; // 当前分配的物理资源 ★
struct ttm_tt *ttm; // 页表对象(GTT/SYSTEM 场景)

struct ttm_device *bdev; // 所属设备
// … 其他字段
};

关系说明:

  • BO 通过 resource 指针获取当前的物理位置和地址
  • BO 迁移时,resource 指针会被替换为新的 resource
  • resource 与 ttm 协同工作(见 5.3)

典型操作:

// 查询 BO 当前位置
uint32_t mem_type = bo->resource->mem_type;
if (mem_type == TTM_PL_VRAM) {
printk("BO in VRAM at offset 0x%lx\\n", bo->resource->start);
}

// BO 迁移
struct ttm_resource *new_res;
ttm_resource_alloc(bo, &place_gtt, &new_res); // 分配 GTT
ttm_bo_move_buffer(bo, new_res); // 迁移数据
ttm_resource_free(bo, &bo->resource); // 释放旧 VRAM
bo->resource = new_res; // 更新指针

5.2 与 ttm_resource_manager 的关系

/**
* struct ttm_resource_manager – TTM 资源管理器
*/

struct ttm_resource_manager {
bool use_type; // 是否启用该类型
bool use_tt; // 是否需要 ttm_tt
struct ttm_device *bdev; // 所属设备
uint64_t size; // 管理的总容量
const struct ttm_resource_manager_func *func; // 操作函数表 ★

spinlock_t move_lock; // 移动锁
struct dma_fence *move; // 移动 fence

struct list_head lru[TTM_MAX_BO_PRIORITY]; // LRU 链表(4 个优先级)★
uint64_t usage; // 当前使用量
// …
};

关系说明:

  • 管理器负责创建和销毁特定类型的 ttm_resource
  • ttm_resource::lru 挂载到管理器的 lru 链表(按优先级)
  • 通过 func 函数表调用具体的分配/释放实现

操作函数表:

struct ttm_resource_manager_func {
int (*alloc)(struct ttm_resource_manager *man,
struct ttm_buffer_object *bo,
const struct ttm_place *place,
struct ttm_resource **res); // 分配资源 ★

void (*free)(struct ttm_resource_manager *man,
struct ttm_resource *res); // 释放资源 ★

bool (*intersects)(struct ttm_resource_manager *man,
struct ttm_resource *res,
const struct ttm_place *place,
size_t size); // 判断是否相交

bool (*compatible)(struct ttm_resource_manager *man,
struct ttm_resource *res,
const struct ttm_place *place,
size_t size); // 判断是否兼容

void (*debug)(struct ttm_resource_manager *man,
struct drm_printer *printer); // 调试信息
};

调用流程:

ttm_resource_alloc(bo, place, &res)
↓
获取对应的 resource_manager (根据 place->mem_type)
↓
man->func->alloc(man, bo, place, &res) ← 调用具体实现
↓
├─ VRAM: ttm_buddy_man_alloc()
├─ GTT: ttm_range_man_alloc()
└─ SYSTEM: ttm_sys_man_alloc()
↓
将 res->lru 加入 man->lru[priority] 链表

5.3 与 ttm_tt 的协作(GTT/SYSTEM 场景)

/**
* struct ttm_tt – TTM 页表对象
*/

struct ttm_tt {
struct page **pages; // 物理页数组 ★
dma_addr_t *dma_address; // DMA 地址数组 ★
uint32_t page_flags; // 页标志
uint32_t num_pages; // 页数量
struct sg_table *sg; // scatter-gather 表
// …
};

协作关系:

  • ttm_resource:描述 GPU 地址空间的分配(GTT 虚拟地址范围)
  • ttm_tt:管理具体的物理页和 DMA 映射

场景 1:GTT 内存分配

1. ttm_resource_alloc() 分配 GTT 地址空间
→ 返回 ttm_range_mgr_node (base.start = GTT 偏移)

2. ttm_tt_create() 创建页表对象
→ 分配 ttm_tt 结构体

3. ttm_tt_populate() 分配物理页
→ 从页池分配 pages[]

4. ttm_tt_map() 建立 DMA 映射
→ 填充 dma_address[]

5. 驱动填充 GTT 页表
→ 将 GTT 地址映射到 dma_address[]

场景 2:CPU 访问 GTT 内存

// CPU mmap 处理
struct ttm_resource *mem = bo->resource; // GTT resource
struct ttm_tt *tt = bo->ttm; // 页表对象

if (mem->mem_type == TTM_PL_TT) {
// 通过 ttm_tt->pages[] 建立 CPU 页表映射
for (i = 0; i < tt->num_pages; i++) {
vm_insert_page(vma, addr, tt->pages[i]);
addr += PAGE_SIZE;
}
}

关系图:

[ttm_buffer_object]
├─> resource ────> [ttm_resource (ttm_range_mgr_node)]
│ ├─> mem_type: TTM_PL_TT
│ ├─> start: 0x10000 (GTT 偏移)
│ ├─> size: 4MB
│ └─> lru ──> [ttm_resource_manager::lru]
│
└─> ttm ─────────> [ttm_tt]
├─> pages[]: [页0, 页1, …, 页1023]
└─> dma_address[]: [DMA0, DMA1, …, DMA1023]
↓
GPU GTT 页表
GTT[0x10000] -> DMA0
GTT[0x10001] -> DMA1
…

核心理解:

  • ttm_resource 是"地址空间分配凭证"(GPU 侧虚拟地址)
  • ttm_tt 是"物理页管理器"(实际的物理内存)
  • 两者配合完成 GPU 的虚拟地址到物理地址的映射

6. 核心操作接口

6.1 分配接口

/**
* ttm_resource_alloc – 分配 TTM 资源
* @bo: 要分配资源的 buffer object
* @place: 放置要求(内存域、对齐、标志等)
* @res: 输出参数,返回分配的 resource
*
* 根据 place 的要求,从对应的资源管理器分配资源。
* place 包含:
* – mem_type: 内存域类型(VRAM/GTT/SYSTEM)
* – fpfn/lpfn: 物理页帧范围(First/Last Page Frame Number)
* – flags: 放置标志(WC/UC/CACHED 等)
*
* 返回: 0 表示成功,-ENOSPC 表示空间不足,负数表示其他错误
*/

int ttm_resource_alloc(struct ttm_buffer_object *bo,
const struct ttm_place *place,
struct ttm_resource **res);

使用示例:

struct ttm_place place = {
.fpfn = 0,
.lpfn = 0, // 0 表示无限制
.mem_type = TTM_PL_VRAM,
.flags = TTM_PL_FLAG_TOPDOWN | TTM_PL_FLAG_CONTIGUOUS,
};

struct ttm_resource *res;
int ret = ttm_resource_alloc(bo, &place, &res);
if (ret == 0) {
printk("分配成功: VRAM 偏移 0x%lx, 大小 %zu\\n",
res->start, res->size);
}

6.2 释放接口

/**
* ttm_resource_free – 释放 TTM 资源
* @bo: 拥有该资源的 buffer object
* @res: 要释放的 resource 指针的指针
*
* 释放资源并将指针置为 NULL。
*/

void ttm_resource_free(struct ttm_buffer_object *bo,
struct ttm_resource **res);

使用示例:

struct ttm_resource *res = bo->resource;
if (res) {
ttm_resource_free(bo, &bo->resource); // 释放并置 NULL
// bo->resource 现在为 NULL
}

6.3 兼容性判断

/**
* ttm_resource_compatible – 判断资源是否与放置要求兼容
* @res: 要检查的资源
* @place: 放置要求
* @size: 所需大小
*
* 用于判断是否可以复用现有资源,避免不必要的迁移。
*
* 返回: true 表示兼容,false 表示需要重新分配
*/

bool ttm_resource_compatible(struct ttm_resource *res,
const struct ttm_place *place,
size_t size);

使用场景:

// BO validation 时检查是否需要迁移
if (bo->resource &&
ttm_resource_compatible(bo->resource, &new_place, bo->base.size)) {
// 当前位置兼容,无需迁移
return 0;
}

// 需要迁移到新位置
ttm_bo_move_buffer(bo, &new_place);

6.4 交集判断(用于 Eviction)

/**
* ttm_resource_intersects – 判断资源是否与放置要求相交
* @res: 要检查的资源
* @place: 放置要求
* @size: 所需大小
*
* 用于 eviction 时判断是否应该驱逐某个 BO。
* 例如:新 BO 需要 VRAM 0x1000-0x2000,检查现有 BO 是否占用该区域。
*
* 返回: true 表示相交(应该驱逐),false 表示不相交
*/

bool ttm_resource_intersects(struct ttm_resource *res,
const struct ttm_place *place,
size_t size);

6.5 CPU 映射准备

/**
* ttm_resource_ioremap – 为 CPU 访问准备 IO 映射
* @bdev: TTM 设备
* @mem: 要映射的资源
* @virtual: 输出参数,返回虚拟地址
*
* 主要用于 VRAM 的 CPU 访问,建立 ioremap 映射。
*
* 返回: 0 表示成功,负数表示错误
*/

int ttm_resource_ioremap(struct ttm_device *bdev,
struct ttm_resource *mem,
void **virtual);

6.6 LRU 管理

/**
* ttm_resource_add_bulk_move – 将资源加入批量移动
* @res: 要加入的资源
* @bulk: 批量移动对象
*
* 用于优化批量 BO 的 LRU 位置更新。
*/

void ttm_resource_add_bulk_move(struct ttm_resource *res,
struct ttm_lru_bulk_move *bulk);

/**
* ttm_lru_item_to_res – 将 LRU 节点转换为 resource
* @item: LRU 节点
*
* 从 LRU 链表遍历时使用。
*/

static inline struct ttm_resource *
ttm_lru_item_to_res(struct ttm_lru_item *item)
{
return container_of(item, struct ttm_resource, lru);
}


7. 实际案例分析

案例 1:VRAM 到 GTT 的迁移

场景:应用分配了过多显存,触发 eviction,需要将不活跃的 BO 从 VRAM 迁移到 GTT。

完整流程:

// 1. 当前 BO 的 resource 指向 VRAM
struct ttm_buffer_object *bo = ...;
struct ttm_resource *old_vram_res = bo->resource;

printk("旧位置: VRAM 偏移 0x%lx\\n", old_vram_res->start);
// 旧位置: VRAM 偏移 0x80000000

// 2. 触发 eviction,选择 GTT 作为目标
struct ttm_place place_gtt = {
.mem_type = TTM_PL_TT,
.flags = TTM_PL_FLAG_CACHED,
};

// 3. 在 GTT 域分配新的 resource
struct ttm_resource *new_gtt_res;
int ret = ttm_resource_alloc(bo, &place_gtt, &new_gtt_res);
if (ret) {
printk("GTT 分配失败: %d\\n", ret);
return ret;
}

printk("新位置: GTT 偏移 0x%lx\\n", new_gtt_res->start);
// 新位置: GTT 偏移 0x10000

// 4. 如果需要,分配 ttm_tt(GTT 需要页表)
if (!bo->ttm) {
ret = ttm_tt_create(bo, true); // true = 需要 CPU 访问
if (ret) {
ttm_resource_free(bo, &new_gtt_res);
return ret;
}

ret = ttm_tt_populate(bo->bdev, bo->ttm, &ctx);
if (ret) {
ttm_resource_free(bo, &new_gtt_res);
return ret;
}
}

// 5. 数据拷贝:VRAM → 临时缓冲区 → GTT
struct ttm_operation_ctx ctx = { .interruptible = true };
ret = ttm_bo_move_memcpy(bo, &ctx, new_gtt_res);
if (ret) {
ttm_resource_free(bo, &new_gtt_res);
return ret;
}

// 内部流程:
// a) 从 VRAM 读取数据到系统内存临时缓冲区
// b) 将数据写入 bo->ttm->pages[]
// c) 更新 GPU 页表,将 GTT 地址映射到 pages[]

// 6. 释放旧的 VRAM resource
ttm_resource_free(bo, &old_vram_res);

// 7. 更新 BO 的 resource 指针
bo->resource = new_gtt_res;

printk("迁移完成: VRAM → GTT\\n");

关键点:

  • VRAM resource 不需要 ttm_tt(直接访问显存)
  • GTT resource 必须有 ttm_tt(管理系统内存页)
  • 数据迁移完成后才能释放旧 resource

案例 2:CPU mmap 访问不同类型的内存

场景:用户空间通过 mmap 访问 BO,驱动需要根据 BO 的 resource 类型建立不同的映射。

// DRM mmap 处理函数(简化版)
static vm_fault_t ttm_bo_vm_fault(struct vm_fault *vmf)
{
struct vm_area_struct *vma = vmf->vma;
struct ttm_buffer_object *bo = vma->vm_private_data;
struct ttm_resource *mem = bo->resource;
unsigned long page_offset;
struct page *page;

if (!mem) {
return VM_FAULT_SIGBUS;
}

page_offset = vmf->pgoff – drm_vma_node_start(&bo->base.vma_node);

switch (mem->mem_type) {
case TTM_PL_VRAM:
// VRAM:使用 IO 映射
if (!mem->bus.is_iomem) {
// 首次访问,建立 IO 映射
ret = ttm_bo_ioremap(bo, 0, bo->base.size, &mem->bus);
if (ret)
return VM_FAULT_SIGBUS;
}

// 使用 vm_insert_pfn_prot 映射 IO 内存
pfn = (mem->bus.offset >> PAGE_SHIFT) + page_offset;

// 设置缓存属性(Write-Combine)
pgprot_t prot = pgprot_writecombine(vma->vm_page_prot);

ret = vm_insert_pfn_prot(vma, vmf->address, pfn, prot);
break;

case TTM_PL_TT:
// GTT:通过 ttm_tt 访问系统内存页
if (!bo->ttm) {
return VM_FAULT_SIGBUS;
}

// 获取对应的物理页
page = bo->ttm->pages[page_offset];

// 使用 vm_insert_page 映射系统内存页
ret = vm_insert_page(vma, vmf->address, page);
break;

case TTM_PL_SYSTEM:
// SYSTEM:直接访问系统内存
page = bo->ttm->pages[page_offset];
ret = vm_insert_page(vma, vmf->address, page);
break;

default:
return VM_FAULT_SIGBUS;
}

return ret ? VM_FAULT_SIGBUS : VM_FAULT_NOPAGE;
}

关键点:

  • VRAM:通过 mem->bus.offset + vm_insert_pfn_prot 映射 IO 内存
  • GTT/SYSTEM:通过 bo->ttm->pages[] + vm_insert_page 映射系统内存页
  • 缓存属性:VRAM 通常使用 WC(Write-Combine),GTT 可能使用 Cached

案例 3:GPU 命令提交时的地址翻译

场景:GPU 需要访问 BO,驱动需要根据 resource 类型填充不同的 GPU 页表。

// GPU 命令提交时更新页表(AMD 驱动简化版)
static int amdgpu_vm_bo_update_mapping(struct amdgpu_device *adev,
struct amdgpu_bo *bo,
struct ttm_resource *mem,
uint64_t va_start,
uint64_t va_size)
{
struct amdgpu_vm *vm = ...;
uint64_t pte_flags = 0;
uint64_t *ptes;
int i, num_ptes;

num_ptes = va_size >> PAGE_SHIFT;

switch (mem->mem_type) {
case TTM_PL_VRAM:
// VRAM:直接映射到 VRAM 物理地址
uint64_t vram_base = adev->gmc.vram_start;
uint64_t phys_addr = vram_base + mem->start;

// 设置 PTE 标志:Valid, Read, Write, VRAM
pte_flags = AMDGPU_PTE_VALID |
AMDGPU_PTE_READABLE |
AMDGPU_PTE_WRITEABLE |
AMDGPU_PTE_VRAM;

// 填充 GPU 页表
for (i = 0; i < num_ptes; i++) {
uint64_t pte = (phys_addr + (i << PAGE_SHIFT)) | pte_flags;
amdgpu_vm_write_pte(vm, va_start + (i << PAGE_SHIFT), pte);
}
break;

case TTM_PL_TT:
// GTT:映射到系统内存 DMA 地址
struct ttm_tt *tt = bo->tbo.ttm;

if (!tt || !tt->dma_address) {
return –EINVAL;
}

// 设置 PTE 标志:Valid, Read, Write, System
pte_flags = AMDGPU_PTE_VALID |
AMDGPU_PTE_READABLE |
AMDGPU_PTE_WRITEABLE |
AMDGPU_PTE_SYSTEM;

// 使用 DMA 地址填充 GPU 页表
for (i = 0; i < num_ptes; i++) {
uint64_t pte = tt->dma_address[i] | pte_flags;
amdgpu_vm_write_pte(vm, va_start + (i << PAGE_SHIFT), pte);
}
break;

case TTM_PL_SYSTEM:
// SYSTEM:与 GTT 类似,但可能需要建立临时 GART 映射
// (部分老旧 GPU 需要通过 GART 访问系统内存)
return amdgpu_gart_map_system_memory(adev, bo, va_start);

default:
return –EINVAL;
}

// 刷新 TLB
amdgpu_vm_flush_tlb(vm);

return 0;
}

关键点:

  • VRAM:GPU 页表直接指向 vram_base + mem->start
  • GTT:GPU 页表指向 ttm_tt->dma_address[](系统内存的 DMA 地址)
  • 页表标志:不同内存类型使用不同的 PTE 标志

8. 常见问题解答

Q1:为什么 GTT 需要 ttm_resource,而不是只用 ttm_tt?

回答:

GTT(Graphics Translation Table)是 GPU 侧的 虚拟地址空间,而 ttm_tt 管理的是 物理页。两者职责完全不同:

  • ttm_resource(具体是 ttm_range_mgr_node):

    • 负责在 GTT 地址空间中分配一段连续的虚拟地址范围
    • 记录分配到的 GTT 偏移(start)和大小(size)
    • 解决"GPU 用什么虚拟地址访问这块内存"的问题
  • ttm_tt:

    • 负责分配实际的系统内存物理页(pages[])
    • 建立 DMA 映射(dma_address[])
    • 解决"这块内存实际在哪些物理页上"的问题

类比理解:

GTT 就像 CPU 的虚拟地址空间(vmalloc 区域)
ttm_resource 就像 vmalloc 返回的虚拟地址范围
ttm_tt 就像实际分配的物理页

实际工作流程:

1. ttm_resource_alloc() 在 GTT 空间分配虚拟地址:0x10000-0x11000
2. ttm_tt_populate() 分配 1024 个物理页
3. ttm_tt_map() 建立 DMA 映射,得到 DMA 地址
4. 驱动填充 GPU 页表:GTT[0x10000] → DMA 地址[0]
GTT[0x10001] → DMA 地址[1]
…

结论:两者缺一不可,ttm_resource 管地址空间,ttm_tt 管物理页。


Q2:SYSTEM 内存的 ttm_resource 有什么用?start 为什么没有意义?

回答:

SYSTEM 类型的 ttm_resource 虽然 start 字段无实际意义,但其他字段仍然非常重要:

仍然有用的字段:

  • mem_type:标识这是 SYSTEM 内存(TTM_PL_SYSTEM)
  • size:记录 BO 的大小,用于资源统计
  • lru:参与 LRU eviction 算法(SYSTEM 内存也可能被驱逐)
  • bo:反向引用,方便从 resource 找到 BO
  • css:cgroup 资源记账

为什么 start 无意义?

  • SYSTEM 内存不需要分配 GPU 地址空间(没有像 GTT 那样的虚拟地址)
  • 物理页由 ttm_tt 的页池直接分配,不是连续的物理地址
  • GPU 访问 SYSTEM 内存通常需要建立临时的 GART 映射或直接通过 PCIe DMA

统一接口的好处:

// 统一的 eviction 逻辑,不需要区分内存类型
struct ttm_resource *res = bo->resource;
if (res->lru.link.next != &res->lru.link) { // 在 LRU 链表中
list_del_init(&res->lru.link); // 从 LRU 移除
}
ttm_resource_free(bo, &bo->resource); // 统一释放接口

结论:ttm_resource 提供了统一的管理接口,即使 SYSTEM 内存不需要地址分配,仍然需要这个"占位符"。


Q3:为什么需要继承 ttm_resource(如 ttm_buddy_resource)?

回答:

不同内存域的管理方式差异巨大,需要额外的私有数据:

VRAM(ttm_buddy_resource):

struct ttm_buddy_resource {
struct ttm_resource base; // 公共字段
struct list_head blocks; // Buddy 分配的内存块链表 ★
unsigned long flags; // 分配标志(CONTIGUOUS/TOPDOWN)★
};

  • 需要记录 Buddy 分配的多个内存块
  • 需要记录分配时的特殊要求(连续分配、从高地址分配等)

GTT(ttm_range_mgr_node):

struct ttm_range_mgr_node {
struct ttm_resource base; // 公共字段
struct drm_mm_node mm_nodes[]; // 地址区间节点(可能多个)★
};

  • 需要记录 drm_mm 分配的地址区间(可能不连续)
  • 柔性数组支持多段分配

继承的优势:

  • 多态性:通过基类指针 ttm_resource * 统一管理
  • 类型安全:通过 container_of 安全地向下转型
  • 扩展性:每个管理器可以添加自己需要的字段
  • 类型转换示例:

    // 统一接口操作
    struct ttm_resource *res = bo->resource;

    // 根据类型转换为具体类型
    if (res->mem_type == TTM_PL_VRAM) {
    struct ttm_buddy_resource *bres;
    bres = container_of(res, struct ttm_buddy_resource, base);

    // 访问 VRAM 特有字段
    list_for_each_entry(block, &bres->blocks, link) {
    printk("Block: offset 0x%llx, size %zu\\n",
    block->offset, block->size);
    }
    }

    结论:继承实现了面向对象的多态,既保证了统一接口,又满足了不同内存域的特殊需求。


    Q4:ttm_resource::bo 为什么是弱引用?

    回答:

    弱引用的含义:

    • 不增加 BO 的引用计数
    • 不阻止 BO 被释放
    • 使用时必须持有 ttm_device::lru_lock

    原因 1:避免循环引用

    ttm_buffer_object
    ├─> resource (强引用) ──> ttm_resource
    └─── 如果 resource->bo 是强引用,形成循环 ──┘

    • 如果是强引用,BO 和 resource 互相持有,导致内存泄漏

    原因 2:LRU 遍历的需要

    // Eviction 时遍历 LRU 链表
    spin_lock(&bdev->lru_lock);
    list_for_each_entry(res, &man->lru[priority], lru.link) {
    struct ttm_buffer_object *bo = res->bo; // 弱引用访问 ★

    if (bo && ttm_bo_evict_swapout_allowable(bo, ctx)) {
    // 驱逐这个 BO
    ttm_bo_evict(bo);
    break;
    }
    }
    spin_unlock(&bdev->lru_lock);

    • eviction 时需要从 resource 找到 BO
    • 但不希望 resource 阻止 BO 被释放

    使用规则:

    // 正确:持有锁访问
    spin_lock(&bdev->lru_lock);
    struct ttm_buffer_object *bo = res->bo;
    if (bo) {
    // 使用 bo
    }
    spin_unlock(&bdev->lru_lock);

    // 错误:不持有锁访问
    struct ttm_buffer_object *bo = res->bo; // 可能已被释放!
    bo->resource = NULL; // 崩溃!

    结论:弱引用避免了循环引用,但访问时必须持有锁保护。


    Q5:如何判断一个 BO 是否可以驱逐(evict)?

    回答:

    eviction 判断涉及多个维度:

    1. LRU 位置(最重要)

    // BO 的 resource 在 LRU 链表中的位置决定了驱逐优先级
    // 链表头部 = 最近使用,链表尾部 = 最久未使用

    list_for_each_entry_reverse(res, &man->lru[priority], lru.link) {
    // 从尾部开始遍历,优先驱逐最久未使用的 BO
    }

    2. Pin 状态

    if (bo->pin_count > 0) {
    // BO 被 pin 住(如正在被 GPU 使用),不能驱逐
    continue;
    }

    3. 优先级

    // LRU 按优先级分为 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, // 可驱逐,最低优先级
    };

    // 驱逐时从低优先级(EVICT)开始
    for (priority = TTM_MAX_BO_PRIORITY – 1; priority >= 0; priority—) {
    list_for_each_entry(res, &man->lru[priority], lru.link) {
    // …
    }
    }

    4. 兼容性检查

    // 检查是否与新分配需求相交
    if (!man->func->intersects(man, res, place, size)) {
    // 不相交,驱逐它也不会释放我们需要的空间
    continue;
    }

    5. 资源量检查

    // 检查是否已经释放了足够的空间
    if (man->size – man->usage >= size) {
    // 已经有足够的空闲空间
    break;
    }

    完整的 eviction 流程:

    int ttm_bo_mem_space(struct ttm_buffer_object *bo,
    struct ttm_placement *placement,
    struct ttm_resource **mem,
    struct ttm_operation_ctx *ctx)
    {
    // 1. 尝试直接分配
    for (i = 0; i < placement->num_placement; i++) {
    ret = ttm_resource_alloc(bo, &placement->placement[i], mem);
    if (ret == 0)
    return 0; // 分配成功
    }

    // 2. 分配失败,触发 eviction
    for (i = 0; i < placement->num_placement; i++) {
    struct ttm_place *place = &placement->placement[i];
    struct ttm_resource_manager *man = ttm_manager_type(bdev, place->mem_type);

    // 遍历 LRU,从低优先级开始
    for (priority = TTM_MAX_BO_PRIORITY – 1; priority >= 0; priority—) {
    list_for_each_entry_safe(res, tmp, &man->lru[priority], lru.link) {
    struct ttm_buffer_object *evict_bo = res->bo;

    // 检查是否可以驱逐
    if (!evict_bo ||
    evict_bo->pin_count > 0 ||
    !man->func->intersects(man, res, place, bo->base.size)) {
    continue;
    }

    // 驱逐这个 BO
    ret = ttm_bo_evict(evict_bo, ctx);
    if (ret)
    continue;

    // 再次尝试分配
    ret = ttm_resource_alloc(bo, place, mem);
    if (ret == 0)
    return 0; // 分配成功
    }
    }
    }

    return –ENOSPC; // 驱逐后仍然失败
    }

    结论:eviction 综合考虑 LRU、pin 状态、优先级、空间需求等多个因素。


    9. 总结

    核心要点

  • 定位:ttm_resource 是"物理内存/地址空间占用凭证",统一描述所有内存域的分配结果

  • 多态设计:通过继承实现不同内存域的特化

    • VRAM → ttm_buddy_resource(Buddy 分配器)
    • GTT → ttm_range_mgr_node(地址区间管理)
    • SYSTEM → 基础 ttm_resource(仅作占位符)
  • 协同工作:

    • 与 ttm_buffer_object:通过 bo->resource 关联
    • 与 ttm_resource_manager:通过 man->func 函数表操作
    • 与 ttm_tt:GTT/SYSTEM 场景下协同管理地址空间和物理页
  • 生命周期:分配 → 使用 → 迁移 → 释放

    • 分配:ttm_resource_alloc() → man->func->alloc()
    • 释放:ttm_resource_free() → man->func->free()
  • 关键字段:

    • start:地址/偏移(VRAM/GTT 有意义,SYSTEM 无意义)
    • mem_type:内存域类型(VRAM/GTT/SYSTEM)
    • size:资源大小
    • lru:参与 eviction 算法
    • bus:CPU mmap 映射信息
  • 本文深入剖析了 ttm_resource 这个核心组件:

    • 是什么:物理内存分配结果的统一抽象
    • 怎么做:通过继承支持不同内存域的特化
    • 如何用:分配、释放、兼容性判断、LRU 管理
    • 与谁协作:BO、资源管理器、页表对象

    打油诗一首:

    ttm_resource 是凭证,地址空间占用证
    VRAM 用 Buddy 块成链,GTT 用区间虚拟段
    SYSTEM 占位符无 start,页表另交 ttm_tt 管
    BO 迁移换 resource,GPU 页表看 start 填
    弱引用避免循环依赖,LRU 驱逐按优先级算


    10. 下一篇预告

    可以看出,ttm_resource是被ttm_resoure_manager的分配和管理的,下一节我们具体分析manager的实现。

    《TTM 资源管理器实现:ttm_resource_manager 深度剖析》

    • ttm_resource_manager 的设计与实现
    • 三种管理器的具体实现:
      • ttm_buddy_manager(VRAM Buddy 分配器)
      • ttm_range_manager(GTT 地址区间管理)
      • ttm_sys_manager(SYSTEM 页池分配)
    • 资源管理器的操作函数表(ttm_resource_manager_func)
    赞(0)
    未经允许不得转载:171主机测评 » 第四章:TTM分析: 4.3 ttm_resource--显存资源分配的核心抽象
    分享到: 更多 (0)

    评论 抢沙发

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