欢迎光临
我们一直在努力

第四章:TTM分析: 4.4 ttm_resource_manager的功能和实现解析

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);
};

函数重要性排序:

  • alloc / free:核心操作,必须实现
  • compatible:判断是否需要迁移,影响性能
  • intersects:eviction 优化,避免无效驱逐
  • debug:调试辅助,非必需

  • 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;
    }

    关键步骤:

  • 分配节点:包含 ttm_resource + drm_mm_node
  • 调用 drm_mm:drm_mm_insert_node_in_range() 在红黑树中查找空闲区间
  • 设置 start:node->base.start = mm_nodes[0].start(GPU 地址)
  • 失败处理:返回 -ENOSPC(空间不足)
  • 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);
    }

    关键步骤:

  • drm_mm_remove_node():从红黑树移除,标记地址区间为空闲
  • ttm_resource_fini():清理 LRU 链表、更新 usage 统计
  • kfree():释放内存
  • 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 的区别:

    特性Range ManagerVRAM 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;
    }

    关键步骤:

  • 分配资源节点:包含 ttm_resource + blocks 链表
  • 循环分配块:可能分配多个 Buddy 块(每个最大 2MB)
  • drm_buddy_alloc_blocks():从 Buddy 管理器分配
  • 设置 start:第一个块的偏移(对于多块分配,start 是起始地址)
  • 更新统计:可见 VRAM 使用量、总使用量
  • 连续分配 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);
    }

    关键步骤:

  • drm_buddy_free_list():释放所有块,自动合并相邻空闲块
  • 更新统计:减少可见 VRAM 使用量
  • 清理资源:标准流程

  • 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;
    }

    初始化顺序:

  • ttm_device_init():初始化 TTM 设备,自动初始化 SYSTEM 管理器
  • amdgpu_vram_mgr_init():初始化 VRAM 管理器(Buddy)
  • amdgpu_gtt_mgr_init():初始化 GTT 管理器(Range)
  • ttm_resource_manager_set_used(true):启用内存域
  • 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;

    关键交互:

  • ttm_manager_type():根据 mem_type 获取管理器
  • man->func->alloc():调用管理器的分配函数(多态)
  • Eviction:分配失败时驱逐旧 BO
  • 回退策略:尝试所有候选位置(VRAM → GTT → SYSTEM)
  • 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);
    }

    清理顺序:

  • 确保所有 BO 已释放
  • 禁用管理器(set_used(false))
  • 注销管理器(set_driver_manager(NULL))
  • 清理内部数据结构(drm_mm / drm_buddy)
  • 清理基类(ttm_resource_manager_fini())

  • 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))
    • 避免死锁:持有互斥锁时可以安全调用其他可睡眠函数

    对比表格:

    特性自旋锁 (Range Manager)互斥锁 (VRAM Manager)
    临界区时长 < 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 管理地址

  • 物理页由 ttm_tt 管理:
  • // 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 没有意义)

    对比表格:

    特性compatibleintersects
    检查对象 当前 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

    核心差异:

    特性VRAM BOGTT BO
    物理内存 GPU 板载内存(固定地址) 系统内存(分散页)
    地址转换 不需要(直接物理地址) 需要(GART/IOMMU 转换)
    ttm_tt ❌ 不需要 ✅ 需要
    resource->start VRAM 物理偏移 GART 虚拟地址
    GPU 访问路径 GPU → VRAM GPU → GART → IOMMU → RAM
    CPU 访问路径 CPU → PCIe → VRAM CPU → RAM

    ttm_tt 的真正作用:

  • 管理物理页:分配、释放、追踪系统内存页
  • DMA 映射:将物理页映射为 DMA 地址(GPU 可访问)
  • GART 绑定:将 DMA 地址填充到 GART 页表
  • 迁移时的变化:

    // 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] ← 已介绍


    赞(0)
    未经允许不得转载:171主机测评 » 第四章:TTM分析: 4.4 ttm_resource_manager的功能和实现解析
    分享到: 更多 (0)

    评论 抢沙发

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