AMDGPU 驱动架构概览

3.2 KFD (Kernel Fusion Driver) 简介

KFD 的历史

KFD 是为 HSA 设计的：

• 目标: 让 CPU 和 GPU 平等协作
• 理念: 'GPU is a first-class compute citizen'
• 特性: 统一地址空间、用户态队列、抢占支持

KFD 的核心组件

┌───────────────────────────────────────┐
│ KFD 驱动 │
├───────────────────────────────────────┤
│ ┌────────────┐ ┌────────────┐ │
│ │进程管理 │ │设备管理 │ │
│ │kfd_process │ │kfd_device │ │
│ └────────────┘ └────────────┘ │
│ ┌────────────┐ ┌─────────────┐ │
│ │队列管理 │ │中断处理 │ │
│ │kfd_queue │ │kfd_interrupt│ │
│ └────────────┘ └─────────────┘ │
│ ┌────────────┐ ┌────────────┐ │
│ │内存管理 │ │拓扑管理 │ │
│ │kfd_svm │ │kfd_topology│ │
│ └────────────┘ └────────────┘ │
│ ┌────────────┐ ┌────────────┐ │
│ │事件管理 │ │调试支持 │ │
│ │kfd_events │ │kfd_debug │ │
│ └────────────┘ └────────────┘ │
└───────────────────────────────────────┘

1. 进程管理（kfd_process.c）

struct kfd_process {
    struct mm_struct *mm; // 进程的内存管理结构
    struct mutex mutex;
    uint32_t pasid; // Process Address Space ID
    struct kfd_process_device *pdds[MAX_GPU_INSTANCE];
    struct svm_range_list svms; // ★ SVM 范围列表
    // 其他成员...
};

作用：

• 每个使用 KFD 的进程都有一个 kfd_process 结构
• 管理进程在所有 GPU 上的资源
• 持有 SVM 范围列表

2. 设备管理（kfd_device.c）

struct kfd_dev {
    struct amdgpu_device *adev; // 指向 AMDGPU 设备
    struct kfd_device_info device_info; // 与 AMDGPU 交互的接口
    const struct kfd2kgd_calls *kfd2kgd; // 设备内存信息
    struct dev_pagemap pgmap; // ★ 设备内存页面映射
    // 其他成员...
};

初始化流程：

GPU 硬件探测
↓
amdgpu 驱动加载
↓
调用 kgd2kfd_probe() ← AMDGPU 通知 KFD
↓
创建 kfd_dev 结构
↓
kgd2kfd_device_init() ← 初始化 KFD 设备
↓
注册到拓扑系统
↓
设备就绪

3. 字符设备接口（kfd_chardev.c）

KFD 通过字符设备暴露给用户空间：

/dev/kfd # 主要接口

IOCTL 命令（部分）：

#define AMDKFD_IOC_CREATE_QUEUE // 创建计算队列
#define AMDKFD_IOC_DESTROY_QUEUE // 销毁队列
#define AMDKFD_IOC_SET_MEMORY_POLICY // 设置内存策略
#define AMDKFD_IOC_SVM // ★ SVM 操作
// ... 更多

SVM IOCTL 流程：

用户空间调用: ioctl(kfd_fd, AMDKFD_IOC_SVM, &args)
↓
kfd_ioctl() 分发
↓
kfd_ioctl_svm() ← kfd_chardev.c
↓
svm_ioctl() ← kfd_svm.c
↓
处理具体的 SVM 操作（添加范围、设置属性等）

3.3 TTM (Translation Table Maps)

什么是 TTM

TTM 是 DRM 子系统提供的 GPU 内存管理框架：

┌────────────────────────────────────┐
│ TTM 框架 │
├────────────────────────────────────┤
│ • 管理 VRAM 和 GTT 内存 │
│ • Buffer Object (BO) 管理 │
│ • 内存驱逐和交换 │
│ • 与系统内存交互 │
└────────────────────────────────────┘
↓ ↓
┌─────────┐ ┌─────────┐
│ VRAM │ │ GTT │
│(GPU 显存) │ │(系统内存)│
└─────────┘ └─────────┘

TTM 的内存域（Memory Domain）

// TTM 定义的内存类型
#define TTM_PL_SYSTEM 0 // 系统 RAM
#define TTM_PL_TT 1 // GTT (Graphics Translation Table)
#define TTM_PL_VRAM 2 // GPU 显存
#define TTM_PL_PRIV 3 // 驱动私有

Buffer Object (BO)

struct amdgpu_bo {
    struct ttm_buffer_object tbo; // TTM BO 基类
    // VRAM 位置
    u64 vram_offset;
    // 偏好域
    u32 preferred_domains;
    // 允许的域
    u32 allowed_domains;
    // 其他成员...
};

BO 的生命周期：

1. 创建 BO amdgpu_bo_create()
↓
分配 TTM 资源
↓
2. 放置 BO（可能在 VRAM 或系统内存）
amdgpu_bo_pin() / ttm_bo_validate()
↓
3. CPU 访问
amdgpu_bo_kmap() ← 建立内核映射
↓
4. GPU 访问
通过 GPU 页表映射
↓
5. 驱逐（内存不足时）
ttm_bo_evict()
↓
移动到系统内存
↓
6. 销毁
amdgpu_bo_unref()

TTM 与 SVM 的关系

SVM 也使用 TTM 管理 VRAM：

// kfd_svm.c 中
struct svm_range_bo {
    struct amdgpu_bo *bo; // ← 使用 TTM BO
    // ...
};

// 分配 VRAM 给 SVM 范围
int svm_range_vram_node_new(...) {
    // 创建 amdgpu_bo
    ret = amdgpu_bo_create(...);
    // ...
}

关键区别：

• 传统 BO：整块分配，显式管理
• SVM：按需分配页面，自动迁移

3.4 GART 表的作用

什么是 GART

GART (Graphics Address Remapping Table) 是 GPU 的地址重映射表，允许 GPU 访问系统内存。

没有 GART: GPU 只能访问 VRAM ✗
有 GART: GPU 可以通过 GART 访问系统 RAM ✓

GART 的工作原理

GPU 视角的地址空间:
┌──────────────────────┐
│ 0x0000_0000 │
│ ... │ ← VRAM (直接映射)
│ VRAM End │
├──────────────────────┤
│ GART Start │
│ ... │ ← GART 窗口（映射系统 RAM）
│ GART End │
└──────────────────────┘

GART 映射表:
GPU 地址 → DMA 地址（系统内存物理地址）

示例：

// 系统内存页面的 DMA 地址：0x8000_1000
// GART 映射：GPU 地址 0xF000_0000 → DMA 0x8000_1000
// GPU 执行：load R1,[0xF000_0000]
// GPU 地址 ↓ GART 查表 ↓ 通过 PCIe 访问 0x8000_1000 // 系统内存

GART 在 SVM 中的使用

SVM 使用 GART 进行页面迁移：

// kfd_migrate.c
// 使用 GART 映射系统内存页面
svm_migrate_gart_map(ring, npages, dma_addr, &gart_addr, flags);

// 使用 SDMA 在 GART 地址和 VRAM 间复制
amdgpu_copy_buffer(ring, gart_addr, vram_addr, size,...);

为什么需要 GART

1. SDMA 只能访问 GPU 地址空间
2. 系统内存不在 GPU 地址空间中
3. GART 将系统内存"映射"到 GPU 地址空间
4. SDMA 现在可以访问系统内存了

流程：

系统内存页面
↓
建立 GART 映射 → GPU 可见地址
↓
SDMA 从 GPU 地址拷贝 → VRAM

3.5 SVM 在驱动中的位置

SVM 的模块划分

kfd_svm.c # SVM 核心逻辑
├─ 范围管理
│  ├─ svm_range_add()
│  ├─ svm_range_unlink()
│  └─ svm_range_split()
├─ 页面映射
│  ├─ svm_range_map_to_gpu()
│  ├─ svm_range_unmap_from_gpu()
│  └─ svm_range_validate_and_map()
├─ 缺页处理
│  ├─ svm_range_restore_pages()
│  └─ 页面恢复逻辑
├─ MMU Notifier
│  └─ svm_range_cpu_invalidate_pagetables()
├─ IOCTL 接口
│  └─ svm_ioctl()
└─ 其他辅助功能

kfd_migrate.c # 页面迁移
├─ RAM → VRAM 迁移
├─ VRAM → RAM 迁移
├─ GART 映射管理
└─ SDMA 复制操作

kfd_svm.h # SVM 数据结构定义

SVM 与其他组件的交互

┌──────────────────────────────┐
│ 用户空间 │
│ (ROCm Runtime) │
└──────────────────────────────┘
↓ IOCTL
========================
内核空间 ========================
↓
┌──────────────┐
│ kfd_chardev │ ← IOCTL 分发
└──────────────┘
↓
┌──────────────┐
│ kfd_svm │ ← SVM 核心
└──────────────┘
↓ ↓ ↓
┌────┐ ┌────┐ ┌────┐
│HMM │ │TTM │ │VM │ ← 内核子系统
└────┘ └────┘ └────┘
↓ ↓ ↓
┌──────────────────┐
│ kfd_migrate │ ← 页面迁移
└──────────────────┘
↓
┌──────────────────┐
│ AMDGPU 驱动 │
│ (SDMA, VM, ...) │
└──────────────────┘
↓
┌──────────────────┐
│ GPU 硬件 │
└──────────────────┘

关键接口

1. KFD ↔ AMDGPU 接口

// include/kgd_kfd_interface.h
struct kfd2kgd_calls {
    // GPU VM 操作
    int (*map_memory_to_gpu)(...);
    int (*unmap_memory_from_gpu)(...);
    // SDMA 操作
    int (*submit_ib)(...);
    // 其他...
};

2. SVM ↔ HMM 接口

// kfd_svm.c 中使用 HMM
// 查询 CPU 页表
ret = hmm_range_fault(&range);

// 迁移页面
ret = migrate_vma_setup(&migrate);
// ...
ret = migrate_vma_finalize(&migrate);

3. SVM ↔ 进程管理接口

// kfd_process.c
struct kfd_process {
    struct svm_range_list svms; // SVM 范围列表
    // ...
};

// 进程初始化时
svm_range_list_init(p);

// 进程退出时
svm_range_list_fini(p);

💡 重点提示

1. 双驱动架构：AMDGPU 负责图形，KFD 负责计算。SVM 在 KFD 中实现。
2. KFD 是核心：SVM 的所有逻辑都在 drivers/gpu/drm/amd/amdkfd/ 目录下。
3. TTM 管理 VRAM：SVM 使用 TTM 的 BO 机制管理 GPU 显存。
4. GART 是桥梁：GART 让 GPU 能够访问系统内存，是迁移的关键。
5. 接口抽象良好：KFD 通过接口与 AMDGPU 交互，解耦合度高。

⚠️ 常见误区

❌ 误区 1：'SVM 是 AMDGPU 驱动的功能'

• ✅ 正确理解：SVM 是 KFD 的功能，虽然依赖 AMDGPU，但主要代码在 KFD 中。

❌ 误区 2：'TTM 和 SVM 是竞争关系'

• ✅ 正确理解：SVM 使用 TTM 管理 VRAM，是合作关系。

❌ 误区 3：'GART 只用于传统内存访问'

• ✅ 正确理解：SVM 页面迁移也大量使用 GART。

❌ 误区 4：'KFD 只支持 AMD GPU'

• ✅ 正确理解：KFD 是 AMD 的实现，但 HSA 理念是通用的。

📝 实践练习

1. 思考题：
   • 为什么需要独立的 KFD 驱动，而不是把所有功能放在 AMDGPU 中？
   • GART 表的大小有限制吗？如果限制，如何影响 SVM？
   • TTM 的驱逐机制如何与 SVM 协作？

系统观察：

# 查看 KFD 设备（需要 AMD GPU 和 ROCm）
ls -l /dev/kfd

# 查看 GPU 拓扑
cat /sys/class/kfd/kfd/topology/nodes/*/name

# 查看 SVM 支持（如果 CONFIG_HSA_AMD_SVM=y）
dmesg | grep -i svm

代码探索：

cd drivers/gpu/drm/amd/amdkfd
# 查看模块初始化
grep -n "module_init\|module_exit" kfd_module.c

# 查看 KFD 与 AMDGPU 的接口
grep -n "kgd2kfd" kfd_device.c | head -20

# 统计 SVM 代码量
wc -l kfd_svm.c kfd_migrate.c

📚 本章小结

• 双驱动架构：AMDGPU（图形）+ KFD（计算）
• KFD 组件：进程管理、设备管理、队列管理、SVM 等
• TTM：GPU 内存管理框架，SVM 使用 TTM 管理 VRAM
• GART：地址重映射表，让 GPU 访问系统内存

理解这些架构层次，有助于在后续章节深入 SVM 的具体实现。

📖 扩展阅读

• KFD 设计文档：Documentation/gpu/amdgpu/driver-misc.rst
• HSA Foundation