GPU 虚拟化与资源管理技术深度解析 - 第二部分：虚拟化技术篇

GPU 虚拟化与资源管理技术深度解析 - 第二部分：虚拟化技术篇

本篇将详细解析GPU虚拟化技术，包括硬件级GPU虚拟化技术、内核态GPU虚拟化技术以及用户态GPU虚拟化技术。我们将深入探讨这些技术的原理、实现机制以及在实际场景中的应用。

目录

• • GPU 虚拟化与资源管理技术深度解析 - 第二部分：虚拟化技术篇
• • 目录
• • 4. 硬件级GPU虚拟化技术
• • 4.1 GPU硬件架构虚拟化基础
• • 4.1.1 流式多处理器（SM）虚拟化机制
• • 4.1.2 内存控制器虚拟化架构
• • 4.2 硬件虚拟化技术深度解析
• • 4.2.1 NVIDIA MIG（Multi-Instance GPU）技术深度解析
• • 4.2.1.1 MIG的工作原理和架构
• • 4.2.1.2 GPU实例的创建和管理
• • 4.2.1.3 硬件级隔离的优势和限制
• • 4.2.1.4 支持的GPU型号和配置选项
• • 4.2.2 AMD SR-IOV虚拟化技术
• • 4.2.3 GPU Passthrough技术
• • 4.3 硬件级虚拟化技术对比与选择
• • 4.3.1 技术特性对比
• • 4.3.2 应用场景选择指南
• • 4.4 本章小结
• • 5. 内核态GPU虚拟化技术
• • 5.1 内核态GPU虚拟化技术架构总览
• • 5.2 内核态虚拟化架构设计
• • 5.2.1 虚拟GPU管理器（VGPU Manager）
• • 5.2.2 资源调度器（Resource Scheduler）
• • 5.2.3 上下文管理器（Context Manager）
• • 5.2.4 内存管理器（Memory Manager）
• • 5.3 高级调度策略与算法
• • 5.3.1 多级反馈队列调度
• • 5.3.2 负载感知调度算法
• • 5.3.3 公平性保证机制
• • 5.4 内核态虚拟化性能优化
• • 5.4.1 上下文切换优化
• • 5.4.2 内存管理优化
• • 5.4.3 I/O调度优化
• • 5.4.4 多GPU协同优化
• • 5.4.5 性能监控与调优
• • 5.5 内核态虚拟化适用场景
• • 6. 用户态GPU虚拟化技术
• • 6.1 CUDA API拦截技术原理
• • 6.1.1 动态库拦截机制
• • 6.1.2 用户态虚拟化技术对比分析
• • 6.2 HAMi实现原理深度解析
• • 6.2.1 HAMi项目架构与技术栈
• • 6.2.2 HAMi-core资源控制机制
• • 6.3 HAMi-core性能优化机制
• • 6.3.1 动态库加载与符号解析优化
• • 6.3.2 内存跟踪与统计优化
• • 6.3.3 日志与调试优化
• • 6.3.4 HAMi-core内存虚拟化算法详解
• • 6.3.5 时间片调度详细实现机制
• • 6.3.6 HAMi性能调优最佳实践
• • 6.4 用户态虚拟化适用场景
• • 6.5 安全性与可靠性机制
• • 6.5.1 多租户环境下的数据隔离机制
• • 6.5.2 侧信道攻击防护机制
• • 6.5.3 API拦截失败时的降级策略
• • 6.5.4 资源配额超限时的处理流程
• • 7. GPU虚拟化技术对比与选择
• • 7.1 GPU虚拟化技术对比分析
• • 7.1.1 技术特性对比
• • 7.1.2 性能影响分析
• • 7.2 GPU虚拟化的核心挑战
• • 7.2.1 资源隔离与共享的平衡
• • 7.2.2 性能损耗控制
• • 7.2.3 多租户环境下的安全性
• • 7.2.4 异构GPU环境的兼容性
• • 7.3 技术选择指南
• • 7.3.1 场景适用性分析
• • 7.3.2 决策矩阵
• • 7.4 本章要点总结
• • 7.5 与GPU切分技术的关系
• • 第二部分总结

4. 硬件级GPU虚拟化技术

本章概览：
本章将深入分析硬件级GPU虚拟化技术，重点探讨NVIDIA MIG、AMD SR-IOV、GPU Passthrough等硬件虚拟化方案的实现原理、技术特点和应用场景。

学习目标：

• • 深入理解GPU硬件架构的虚拟化支持机制
• • 掌握NVIDIA MIG、AMD SR-IOV等硬件虚拟化技术
• • 了解硬件级资源隔离的技术原理
• • 理解异构GPU环境的硬件差异和统一管理挑战

4.1 GPU硬件架构虚拟化基础

4.1.1 流式多处理器（SM）虚拟化机制

SM架构与虚拟化支持：

现代GPU的SM（Streaming Multiprocessor）是GPU计算的核心单元，其虚拟化机制直接影响GPU资源分配的粒度和效率。

NVIDIA Ampere架构SM虚拟化特性：

• • 硬件级分区支持：每个SM包含64个CUDA核心，支持硬件级的资源分区
• • 独立调度器：每个SM配备4个warp调度器，支持独立的任务调度
• • 专用寄存器文件：65536个32位寄存器，支持上下文隔离
• • 共享内存分区：128KB共享内存支持动态分区和隔离

// SM虚拟化管理结构
typedefstruct {
uint32_t sm_id;                    // SM标识符
uint32_t allocated_cores;          // 已分配的CUDA核心数
uint32_t total_cores;              // 总CUDA核心数
uint32_t allocated_registers;      // 已分配寄存器数量
uint32_t shared_memory_partition;  // 共享内存分区大小
uint32_t warp_scheduler_mask;      // warp调度器分配掩码
structvgpu_context *contexts[MAX_VGPU_PER_SM];// 虚拟GPU上下文
} sm_virtualization_t;

// SM资源分配函数
intallocate_sm_resources(sm_virtualization_t *sm, 
uint32_t vgpu_id, 
uint32_t core_count, 
uint32_t register_count) {
// 检查资源可用性
if (sm->allocated_cores + core_count > sm->total_cores) {
return -ENOMEM; // 内存不足
    }

// 分配CUDA核心
    sm->allocated_cores += core_count;

// 分配寄存器资源
    sm->allocated_registers += register_count;

// 更新调度器掩码
    sm->warp_scheduler_mask |= (1 << vgpu_id);

return0; // 分配成功
}

AMD RDNA架构计算单元虚拟化：

• • 计算单元（CU）分区：每个CU包含64个流处理器，支持工作组级别的隔离
• • 波前调度器：独立的波前调度机制，支持多租户并发
• • 标量寄存器文件：2048个标量寄存器，支持上下文保存和恢复
• • 本地数据共享（LDS）：64KB LDS支持动态分区

4.1.2 内存控制器虚拟化架构

内存控制器虚拟化的核心挑战：

内存控制器是GPU性能的关键瓶颈，其虚拟化实现直接影响多租户环境下的性能隔离效果。

NVIDIA HBM内存控制器虚拟化：

// 内存控制器虚拟化结构
typedefstruct {
uint32_t mc_id;                    // 内存控制器ID
uint64_t total_bandwidth;          // 总内存带宽（GB/s）
uint64_t allocated_bandwidth;      // 已分配带宽
uint32_t channel_count;            // 内存通道数量
uint32_t partition_mask;           // 分区掩码
struct {
uint32_t vgpu_id;              // 虚拟GPU标识符
uint64_t bandwidth_quota;      // 带宽配额
uint32_t priority;             // 优先级
uint64_t access_pattern;       // 访问模式统计
    } partitions[MAX_MEMORY_PARTITIONS];
} memory_controller_virt_t;

// 内存带宽分配函数
intallocate_memory_bandwidth(memory_controller_virt_t *mc,
uint32_t vgpu_id,
uint64_t bandwidth_request) {
// 检查带宽可用性
if (mc->allocated_bandwidth + bandwidth_request > mc->total_bandwidth) {
return -ENOSPC; // 空间不足
    }

// 查找空闲分区
for (int i = 0; i < MAX_MEMORY_PARTITIONS; i++) {
if (mc->partitions[i].vgpu_id == 0) {
            mc->partitions[i].vgpu_id = vgpu_id;
            mc->partitions[i].bandwidth_quota = bandwidth_request;
            mc->allocated_bandwidth += bandwidth_request;
            mc->partition_mask |= (1 << i);
return i; // 返回分区索引
        }
    }

return -ENOMEM; // 内存不足
}

4.2 硬件虚拟化技术深度解析

硬件级GPU虚拟化技术架构总览：

硬件级GPU虚拟化技术通过GPU硬件内置的虚拟化功能实现资源隔离和管理，是目前性能最优、隔离性最强的GPU虚拟化方案。下图展示了三种主要的硬件级虚拟化技术架构：

如图所示，硬件级GPU虚拟化技术主要包括：

1. 1. NVIDIA MIG技术：通过硬件级资源切分，将单个GPU划分为多个独立的MIG实例，每个实例拥有专用的SM和内存切片，实现完全的硬件级隔离。支持1g.5gb、2g.10gb、3g.20gb、7g.40gb等多种配置选项，适用于AI训练和推理场景。
2. 2. AMD SR-IOV技术：基于PCIe SR-IOV标准，通过物理功能(PF)和虚拟功能(VF)实现GPU虚拟化。每个VF作为独立的PCIe设备，提供硬件级隔离，特别适用于虚拟化环境和云计算平台。
3. 3. GPU Passthrough技术：通过VFIO/IOMMU技术将整个物理GPU直接分配给虚拟机，提供接近裸机的性能表现。虽然资源利用率相对较低，但在需要完整GPU功能和最高性能的场景中具有重要价值。

这三种技术在隔离级别、性能开销、部署复杂度和硬件要求方面各有特点，需要根据具体的应用场景和需求进行选择。MIG技术的性能开销最低（<5%），SR-IOV的部署复杂度较高，而Passthrough技术提供最完整的GPU功能访问。

4.2.1 NVIDIA MIG（Multi-Instance GPU）技术深度解析

4.2.1.1 MIG的工作原理和架构

MIG技术基于NVIDIA Ampere架构的硬件设计特性，通过以下核心机制实现GPU的物理级切分：

1. 1. 计算单元分割：将GPU的流式多处理器（SM）按预定义配置进行分组，为每个MIG实例分配专用的SM集群
2. 2. 显存分割：为每个MIG实例分配独立的显存地址空间，通过硬件级内存保护机制确保访问隔离
3. 3. 内存控制器分割：每个MIG实例配备独立的内存控制器，从硬件层面保障内存带宽的完全隔离
4. 4. 硬件调度器分割：为每个实例提供独立的硬件调度器，消除实例间的调度竞争和干扰

MIG技术核心特性：

• • 硬件级隔离：每个MIG实例拥有独立的硬件资源，实现真正的物理隔离
• • 预定义配置：支持1g.5gb、2g.10gb、3g.20gb、7g.40gb等标准配置
• • 完全独立：每个实例具有独立的错误域和故障隔离能力

扩展阅读：MIG在容器化环境中的具体应用和HAMi集成实现，详见 8.1 HAMi结合硬件级GPU切分技术

4.2.1.2 GPU实例的创建和管理

MIG实例管理涉及GPU实例(GI)和计算实例(CI)的两级创建过程：

基础配置流程：

# 启用MIG模式（需要重启GPU）
nvidia-smi -i 0 -mig 1

# 创建GPU实例
nvidia-smi mig -i 0 -cgi 19,19,19 -C

# 创建计算实例
nvidia-smi mig -i 0 -cci

# 验证配置
nvidia-smi -L

实践参考：完整的MIG管理脚本实现见 mig_management.sh
集成应用：HAMi环境下的MIG自动化管理见 8.1.2 HAMi MIG Device Plugin实现

MIG资源分配策略：

/**
 * @brief MIG实例配置结构体
 * @details 定义MIG实例的硬件资源配置参数
 */
typedefstruct {
uint32_t gi_id;                    /**< GPU实例ID */
uint32_t ci_id;                    /**< 计算实例ID */
uint32_t sm_count;                 /**< 流式多处理器数量 */
uint64_t memory_size;              /**< 分配的显存大小(字节) */
uint32_t memory_slice_count;       /**< 内存切片数量 */
uint32_t compute_slice_count;      /**< 计算切片数量 */
} mig_instance_config_t;

/**
 * @brief 创建MIG实例
 * @param gpu_id 目标GPU设备ID
 * @param config MIG实例配置参数
 * @return 成功返回0，失败返回负数错误码
 * @note 详细实现参见 @ref 8.1.2 "HAMi MIG Device Plugin实现"
 */
intcreate_mig_instance(uint32_t gpu_id, 
mig_instance_config_t *config) {
/* 检查资源可用性 */
if (!check_mig_resources_available(gpu_id, config)) {
return -ENOSPC;
    }

/* 创建GPU实例 */
int gi_id = create_gpu_instance(gpu_id, config->sm_count, 
                                   config->memory_slice_count);
if (gi_id < 0) {
return gi_id;
    }

/* 创建计算实例 */
int ci_id = create_compute_instance(gi_id, 
                                       config->compute_slice_count);
if (ci_id < 0) {
        destroy_gpu_instance(gi_id);
return ci_id;
    }

    config->gi_id = gi_id;
    config->ci_id = ci_id;

return0;
}

关键实现要点：

• • 资源验证：创建前检查可用的SM和内存资源
• • 两级创建：先创建GPU实例(GI)，再创建计算实例(CI)
• • 状态管理：维护实例配置和可用性状态
• • 错误处理：创建失败时自动清理已分配资源

部署要求：

• • 硬件支持：仅限A100、A30、A40、H100等支持MIG的GPU
• • 驱动版本：NVIDIA驱动 ≥ 450.80.02，CUDA ≥ 11.0
• • 权限要求：需要root权限，启用MIG需重启GPU

详细实现：完整的管理脚本和函数实现见 mig_management.sh

4.2.1.3 硬件级隔离的优势和限制

优势：

• • 完全隔离：硬件级别的资源隔离，确保实例间完全独立
• • 性能保障：每个实例拥有专用的硬件资源，性能可预测
• • 安全性高：硬件级别的隔离提供最高级别的安全保障
• • 故障隔离：一个实例的故障不会影响其他实例

限制：

• • 硬件依赖：仅支持特定的 GPU 型号（A100、A30、A40 等）
• • 配置固定：实例配置相对固定，动态调整能力有限
• • 资源粒度：切分粒度受硬件设计限制，无法实现任意大小的分割
• • 成本较高：需要支持 MIG 的高端 GPU，成本相对较高

4.2.1.4 支持的GPU型号和配置选项

支持的 GPU 型号：

• • NVIDIA A100（40GB/80GB）
• • NVIDIA A30
• • NVIDIA A40
• • NVIDIA H100

配置选项：

• • 1g.5gb：1/7 GPU + 5GB 显存
• • 2g.10gb：2/7 GPU + 10GB 显存
• • 3g.20gb：3/7 GPU + 20GB 显存
• • 4g.20gb：4/7 GPU + 20GB 显存
• • 7g.40gb：完整 GPU + 40GB 显存（A100 40GB）
• • 7g.80gb：完整 GPU + 80GB 显存（A100 80GB）

4.2.2 AMD SR-IOV虚拟化技术

SR-IOV架构特点：

• • 物理功能（PF）：完整的GPU功能，包含配置和管理能力
• • 虚拟功能（VF）：轻量级的GPU功能，专注于数据处理
• • 硬件级隔离：每个VF拥有独立的内存空间和寄存器组

// SR-IOV虚拟功能配置
typedefstruct {
uint16_t vf_id;                    // 虚拟功能ID
uint32_t compute_units;            // 分配的计算单元数
uint64_t memory_quota;             // 内存配额
uint32_t bandwidth_limit;          // 带宽限制
bool isolation_enabled;            // 是否启用隔离
} sriov_vf_config_t;

// 配置SR-IOV虚拟功能
intconfigure_sriov_vf(uint16_t vf_id, sriov_vf_config_t *config) {
// 设置计算单元分配
    write_vf_register(vf_id, VF_COMPUTE_UNITS_REG, 
                     config->compute_units);

// 设置内存配额
    write_vf_register(vf_id, VF_MEMORY_QUOTA_REG, 
                     config->memory_quota);

// 启用隔离机制
if (config->isolation_enabled) {
        write_vf_register(vf_id, VF_ISOLATION_REG, 1);
    }

return0;
}

4.2.3 GPU Passthrough技术

Passthrough实现机制：

GPU Passthrough通过IOMMU技术将物理GPU直接分配给虚拟机，实现接近裸机的性能。

// GPU Passthrough配置结构
typedefstruct {
uint32_t gpu_pci_id;               // GPU PCI设备ID
uint32_t vm_id;                    // 虚拟机ID
uint64_t iommu_domain;             // IOMMU域
bool vfio_enabled;                 // VFIO是否启用
} gpu_passthrough_config_t;

// GPU Passthrough配置函数
intconfigure_gpu_passthrough(gpu_passthrough_config_t *config) {
// 解绑原有驱动
    unbind_gpu_driver(config->gpu_pci_id);

// 绑定VFIO驱动
    bind_vfio_driver(config->gpu_pci_id);

// 配置IOMMU映射
    setup_iommu_mapping(config->gpu_pci_id, 
                       config->iommu_domain);

// 分配给虚拟机
    assign_device_to_vm(config->gpu_pci_id, config->vm_id);

return0; // 配置成功
}

4.3 硬件级虚拟化技术对比与选择

4.3.1 技术特性对比

4.3.2 应用场景选择指南

NVIDIA MIG适用场景：

• • AI训练和推理工作负载的多租户隔离
• • 需要硬件级安全隔离的云计算环境
• • 资源利用率要求较高的数据中心
• • 支持动态资源调整的弹性计算场景

AMD SR-IOV适用场景：

• • 传统虚拟化环境的GPU加速
• • 需要PCIe级别隔离的企业应用
• • 多虚拟机共享GPU资源的场景
• • 对硬件兼容性要求较高的环境

GPU Passthrough适用场景：

• • 高性能计算(HPC)应用
• • 需要完整GPU功能的专业应用
• • 对性能要求极高的图形工作站
• • 单一虚拟机独占GPU的场景

4.4 本章小结

本章深入分析了硬件级GPU虚拟化技术的核心原理和实现方案。通过对NVIDIA MIG、AMD SR-IOV和GPU Passthrough三种主要技术的详细解析，我们可以得出以下关键结论：

技术成熟度与应用现状：

• • NVIDIA MIG技术已成为AI训练集群中最主流的硬件级虚拟化方案，其硬件级隔离和低性能开销(<5%)使其在多租户环境中具有显著优势
• • AMD SR-IOV技术在传统虚拟化环境中表现良好，但部署复杂度较高，需要完整的SR-IOV生态支持
• • GPU Passthrough技术虽然资源利用率相对较低，但在HPC和专业图形应用中仍具有不可替代的价值

核心技术优势：

1. 1. 硬件级隔离保障：所有三种技术都提供了硬件层面的资源隔离，确保了多租户环境的安全性和稳定性
2. 2. 接近裸机性能：性能开销均控制在10%以内，其中MIG和Passthrough的开销更是低于5%
3. 3. 完整的生态支持：主流GPU厂商都提供了相应的硬件和软件支持

技术发展趋势：

• • 硬件级虚拟化将继续向更细粒度、更灵活的资源分配方向发展
• • 多GPU协同和跨节点资源池化将成为重要发展方向
• • 与容器化技术的深度集成将进一步提升部署和管理效率

实践建议：

• • 在选择硬件级虚拟化方案时，应综合考虑应用场景、性能要求、硬件成本和运维复杂度
• • 对于AI训练集群，推荐优先考虑NVIDIA MIG技术
• • 对于传统虚拟化环境，可考虑AMD SR-IOV或GPU Passthrough方案
• • 在实际部署前，建议进行充分的性能测试和兼容性验证

硬件级GPU虚拟化技术为现代数据中心提供了强大的GPU资源管理能力，是构建高效、安全、可扩展的GPU计算平台的重要技术基础。随着AI和HPC应用的持续发展，这些技术将在未来的计算基础设施中发挥越来越重要的作用。

5. 内核态GPU虚拟化技术

本章概览：
本章将深入探讨内核态GPU虚拟化技术，包括内核级资源管理、虚拟GPU驱动架构、上下文切换机制以及性能优化策略。

学习目标：

• • 理解内核态虚拟化的架构设计和实现原理
• • 掌握虚拟GPU驱动的核心技术
• • 了解内核级资源调度和隔离机制
• • 学习内核态虚拟化的性能优化方法

5.1 内核态GPU虚拟化技术架构总览

内核态GPU虚拟化技术通过在操作系统内核层面实现GPU资源的虚拟化管理，在性能和安全性之间取得了良好的平衡。

该技术通过修改或拦截GPU硬件驱动程序，在内核空间实现资源管理和调度，具有系统级控制、精细资源管理的特点，需要内核模块支持。与用户态虚拟化相比，内核态虚拟化具有更强的系统级控制能力和更精细的资源管理机制；与硬件级虚拟化相比，内核态虚拟化具有更好的灵活性和兼容性。

内核态虚拟化层（核心控制层）：

• • 功能定位：GPU虚拟化的核心控制层，通过内核拦截机制实现资源管理和调度
• • 核心技术特点：
• • 系统级控制能力：在内核空间直接管理GPU资源，具有最高权限
• • 精细资源管理：支持细粒度的资源分配和配额控制
• • 内核模块支持：需要加载专用的内核模块来实现虚拟化功能
• • 强隔离保证：通过内核级隔离机制确保多租户安全
• • 核心组件及内核拦截机制：
• • 虚拟GPU驱动架构：管理虚拟GPU实例的生命周期，拦截GPU驱动调用
• • 内核级资源调度：实现GPU计算资源的时间片调度和优先级管理
• • GPU内存虚拟化：提供内存隔离和虚拟地址空间管理，拦截内存映射操作
• • 系统调用拦截模块：拦截关键系统调用（如ioctl、mmap）实现资源控制
• • 性能优化模块：优化上下文切换和内存管理性能

内核拦截技术实现细节：

内核态虚拟化的核心在于通过内核拦截机制实现对GPU资源的精确控制：

• • ioctl系统调用拦截：拦截GPU设备的ioctl调用，实现命令过滤和资源配额检查
• • mmap内存映射拦截：拦截GPU内存映射操作，实现虚拟地址空间管理和访问权限控制
• • 驱动程序修改：通过修改GPU驱动程序，在关键路径上插入虚拟化逻辑
• • 内核模块加载：加载专用的内核模块来实现GPU资源的虚拟化管理

数据流向分析：

1. 1. 应用调用阶段：应用程序通过系统调用接口请求GPU资源
2. 2. 内核拦截阶段：内核态虚拟化层捕获并分析资源请求
3. 3. 资源调度阶段：通过内核级调度器进行资源分配和优先级管理
4. 4. 硬件执行阶段：物理GPU硬件执行实际的计算任务

这种基于内核拦截的分层架构设计确保了内核态GPU虚拟化技术既能提供强大的系统级控制能力和精细化资源管理，又能保持良好的性能表现和应用兼容性。

5.2 内核态虚拟化架构设计

内核态虚拟化通过在操作系统内核层面实现GPU资源的虚拟化管理，提供了较好的性能和安全性平衡。本节将详细介绍内核态虚拟化的四个核心组件：虚拟GPU管理器、资源调度器、上下文管理器和内存管理器。

技术特点：

• • 内核级资源管理：在操作系统内核层面实现GPU资源的分配和调度
• • 硬件抽象层：为上层应用提供统一的GPU访问接口
• • 安全隔离：利用操作系统的权限管理机制实现安全隔离
• • 性能优化：减少用户态和内核态之间的上下文切换开销

5.2.1 虚拟GPU管理器（VGPU Manager）

虚拟GPU管理器是内核态虚拟化的核心组件，负责虚拟GPU实例的完整生命周期管理，包括创建、配置、监控和销毁等操作。

核心功能：

• • 实例生命周期管理：创建、启动、暂停、恢复和销毁虚拟GPU实例
• • 资源配额分配：为每个虚拟GPU实例分配计算资源和内存资源
• • 状态监控：实时监控虚拟GPU实例的运行状态和资源使用情况
• • 故障处理：检测和处理虚拟GPU实例的异常情况

数据结构设计：

// 虚拟GPU实例结构
structvgpu_instance {
uint32_t instance_id;              // 实例唯一标识符
uint32_t physical_gpu_id;          // 绑定的物理GPU ID
enumvgpu_statestate;// 实例状态

// 资源配额
struct {
uint32_t compute_units;         // 分配的计算单元数
uint64_t memory_quota;          // 内存配额（字节）
uint32_t bandwidth_quota;       // 带宽配额（MB/s）
uint32_t priority;              // 调度优先级
    } resource_quota;

// 运行时状态
struct {
uint64_t creation_time;         // 创建时间
uint64_t last_active_time;      // 最后活跃时间
uint64_t total_execution_time;  // 累计执行时间
uint32_t context_switches;      // 上下文切换次数
uint64_t memory_usage;          // 当前内存使用量
    } runtime_stats;

// 关联的上下文和内存管理器
structvgpu_context *context;// 执行上下文
structvgpu_memory_space *memory;// 内存空间

// 链表节点
structlist_headinstance_list;// 实例链表
structhlist_nodehash_node;// 哈希表节点

// 同步原语
structmutexinstance_mutex;// 实例互斥锁
atomic_t ref_count;                // 引用计数
};

// 虚拟GPU管理器结构
structvgpu_manager {
uint32_t max_instances;            // 最大实例数
uint32_t active_instances;         // 当前活跃实例数

// 实例管理
structlist_headinstance_list;// 实例链表
    DECLARE_HASHTABLE(instance_hash, 8); // 实例哈希表
structidrinstance_idr;// 实例ID分配器

// 资源管理
struct {
uint32_t total_compute_units;   // 总计算单元数
uint32_t available_compute_units; // 可用计算单元数
uint64_t total_memory;          // 总内存大小
uint64_t available_memory;      // 可用内存大小
    } resource_pool;

// 同步和保护
structrw_semaphoremanager_rwsem;// 管理器读写信号量
spinlock_t instance_lock;          // 实例操作锁

// 工作队列
structworkqueue_struct *mgr_wq;// 管理工作队列
structdelayed_workcleanup_work;// 清理工作
};

核心操作实现：

// 创建虚拟GPU实例
struct vgpu_instance *vgpu_create_instance(struct vgpu_manager *mgr,
struct vgpu_create_params *params) {
structvgpu_instance *instance;
int ret;

// 参数验证
if (!mgr || !params) {
        pr_err("无效的参数\n");
return ERR_PTR(-EINVAL);
    }

// 检查资源可用性
    down_read(&mgr->manager_rwsem);
if (mgr->active_instances >= mgr->max_instances) {
        up_read(&mgr->manager_rwsem);
        pr_warn("已达到最大实例数限制: %u\n", mgr->max_instances);
return ERR_PTR(-ENOSPC);
    }

if (params->compute_units > mgr->resource_pool.available_compute_units ||
        params->memory_quota > mgr->resource_pool.available_memory) {
        up_read(&mgr->manager_rwsem);
        pr_warn("资源不足: 请求计算单元=%u(可用=%u), 请求内存=%llu(可用=%llu)\n",
                params->compute_units, mgr->resource_pool.available_compute_units,
                params->memory_quota, mgr->resource_pool.available_memory);
return ERR_PTR(-ENOMEM);
    }
    up_read(&mgr->manager_rwsem);

// 分配实例结构
    instance = kzalloc(sizeof(*instance), GFP_KERNEL);
if (!instance) {
return ERR_PTR(-ENOMEM);
    }

// 初始化实例
    down_write(&mgr->manager_rwsem);

// 分配实例ID
    ret = idr_alloc(&mgr->instance_idr, instance, 1, 0, GFP_KERNEL);
if (ret < 0) {
        up_write(&mgr->manager_rwsem);
        kfree(instance);
        pr_err("分配实例ID失败: %d\n", ret);
return ERR_PTR(ret);
    }
    instance->instance_id = ret;

// 设置资源配额
    instance->resource_quota.compute_units = params->compute_units;
    instance->resource_quota.memory_quota = params->memory_quota;
    instance->resource_quota.bandwidth_quota = params->bandwidth_quota;
    instance->resource_quota.priority = params->priority;

// 更新资源池
    mgr->resource_pool.available_compute_units -= params->compute_units;
    mgr->resource_pool.available_memory -= params->memory_quota;

// 初始化运行时状态
    instance->state = VGPU_STATE_CREATED;
    instance->runtime_stats.creation_time = ktime_get_ns();
    instance->runtime_stats.last_active_time = instance->runtime_stats.creation_time;

// 初始化同步原语
    mutex_init(&instance->instance_mutex);
atomic_set(&instance->ref_count, 1);

// 添加到管理器
    list_add_tail(&instance->instance_list, &mgr->instance_list);
    hash_add(mgr->instance_hash, &instance->hash_node, instance->instance_id);
    mgr->active_instances++;

    up_write(&mgr->manager_rwsem);

    pr_info("创建虚拟GPU实例成功: ID=%u, 计算单元=%u, 内存=%llu MB\n",
            instance->instance_id, params->compute_units, 
            params->memory_quota / (1024 * 1024));

return instance;
}

// 销毁虚拟GPU实例
intvgpu_destroy_instance(struct vgpu_manager *mgr, uint32_t instance_id) {
structvgpu_instance *instance;
int ret = 0;

    down_write(&mgr->manager_rwsem);

// 查找实例
    instance = idr_find(&mgr->instance_idr, instance_id);
if (!instance) {
        up_write(&mgr->manager_rwsem);
        pr_warn("未找到实例: ID=%u\n", instance_id);
return -ENOENT;
    }

// 检查实例状态
    mutex_lock(&instance->instance_mutex);
if (instance->state == VGPU_STATE_RUNNING) {
// 强制停止实例
        ret = vgpu_stop_instance_locked(instance);
if (ret) {
            mutex_unlock(&instance->instance_mutex);
            up_write(&mgr->manager_rwsem);
            pr_err("停止实例失败: ID=%u, 错误=%d\n", instance_id, ret);
return ret;
        }
    }

// 清理资源
if (instance->context) {
        vgpu_destroy_context(instance->context);
        instance->context = NULL;
    }

if (instance->memory) {
        vgpu_destroy_memory_space(instance->memory);
        instance->memory = NULL;
    }

// 释放资源配额
    mgr->resource_pool.available_compute_units += instance->resource_quota.compute_units;
    mgr->resource_pool.available_memory += instance->resource_quota.memory_quota;

// 从管理器移除
    list_del(&instance->instance_list);
    hash_del(&instance->hash_node);
    idr_remove(&mgr->instance_idr, instance_id);
    mgr->active_instances--;

    instance->state = VGPU_STATE_DESTROYED;
    mutex_unlock(&instance->instance_mutex);

    up_write(&mgr->manager_rwsem);

// 释放实例内存
    kfree(instance);

    pr_info("销毁虚拟GPU实例成功: ID=%u\n", instance_id);
return0;
}

// 启动虚拟GPU实例
intvgpu_start_instance(struct vgpu_manager *mgr, uint32_t instance_id) {
structvgpu_instance *instance;
int ret;

    down_read(&mgr->manager_rwsem);

    instance = idr_find(&mgr->instance_idr, instance_id);
if (!instance) {
        up_read(&mgr->manager_rwsem);
return -ENOENT;
    }

    mutex_lock(&instance->instance_mutex);

if (instance->state != VGPU_STATE_CREATED && 
        instance->state != VGPU_STATE_STOPPED) {
        mutex_unlock(&instance->instance_mutex);
        up_read(&mgr->manager_rwsem);
        pr_warn("实例状态不允许启动: ID=%u, 状态=%d\n", 
                instance_id, instance->state);
return -EINVAL;
    }

// 创建执行上下文
if (!instance->context) {
        instance->context = vgpu_create_context(instance);
if (IS_ERR(instance->context)) {
            ret = PTR_ERR(instance->context);
            instance->context = NULL;
            mutex_unlock(&instance->instance_mutex);
            up_read(&mgr->manager_rwsem);
            pr_err("创建上下文失败: ID=%u, 错误=%d\n", instance_id, ret);
return ret;
        }
    }

// 创建内存空间
if (!instance->memory) {
        instance->memory = vgpu_create_memory_space(instance);
if (IS_ERR(instance->memory)) {
            ret = PTR_ERR(instance->memory);
            instance->memory = NULL;
            vgpu_destroy_context(instance->context);
            instance->context = NULL;
            mutex_unlock(&instance->instance_mutex);
            up_read(&mgr->manager_rwsem);
            pr_err("创建内存空间失败: ID=%u, 错误=%d\n", instance_id, ret);
return ret;
        }
    }

// 更新状态
    instance->state = VGPU_STATE_RUNNING;
    instance->runtime_stats.last_active_time = ktime_get_ns();

    mutex_unlock(&instance->instance_mutex);
    up_read(&mgr->manager_rwsem);

    pr_info("启动虚拟GPU实例成功: ID=%u\n", instance_id);
return0;
}

5.2.2 资源调度器（Resource Scheduler）

资源调度器负责在多个虚拟GPU实例之间公平、高效地分配物理GPU资源，包括计算资源、内存资源和I/O带宽等。

调度策略：

• • 时间片轮转调度：为每个虚拟GPU实例分配固定的时间片
• • 优先级调度：根据实例优先级进行抢占式调度
• • 公平共享调度：确保资源在实例间公平分配
• • 负载感知调度：根据实际负载动态调整调度策略

数据结构设计：

// 调度队列节点
structsched_entity {
structvgpu_instance *instance;// 关联的虚拟GPU实例
uint32_t priority;                 // 调度优先级
uint64_t time_slice_ns;            // 时间片长度（纳秒）
uint64_t remaining_time_ns;        // 剩余时间片
uint64_t total_runtime_ns;         // 累计运行时间
uint64_t last_scheduled_time;      // 上次调度时间
uint32_t preemption_count;         // 被抢占次数

// 调度统计
struct {
uint64_t wait_time_ns;          // 等待时间
uint64_t response_time_ns;      // 响应时间
uint32_t schedule_count;        // 调度次数
float cpu_utilization;         // CPU利用率
    } sched_stats;

structlist_headsched_list;// 调度队列链表
};

// GPU资源调度器
structgpu_scheduler {
// 调度队列
structlist_headready_queue;// 就绪队列
structlist_headwaiting_queue;// 等待队列
structlist_headblocked_queue;// 阻塞队列

// 当前调度状态
structsched_entity *current_entity;// 当前运行的调度实体
uint64_t current_time_slice_start;  // 当前时间片开始时间

// 调度参数
uint64_t default_time_slice_ns;     // 默认时间片长度
uint32_t max_priority;              // 最大优先级
uint32_t preemption_threshold;      // 抢占阈值

// 调度统计
struct {
uint64_t total_context_switches;  // 总上下文切换次数
uint64_t total_preemptions;       // 总抢占次数
uint64_t average_response_time;   // 平均响应时间
float system_utilization;         // 系统利用率
    } global_stats;

// 同步原语
spinlock_t sched_lock;             // 调度器锁
structtimer_listpreemption_timer;// 抢占定时器

// 工作队列
structworkqueue_struct *sched_wq;// 调度工作队列
structwork_structschedule_work;// 调度工作
};

核心调度算法：

// 选择下一个要调度的实体
struct sched_entity *select_next_entity(struct gpu_scheduler *sched) {
structsched_entity *entity, *best_entity =NULL;
uint32_t highest_priority = 0;
uint64_t current_time = ktime_get_ns();

// 遍历就绪队列，选择优先级最高的实体
    list_for_each_entry(entity, &sched->ready_queue, sched_list) {
// 检查实例状态
if (entity->instance->state != VGPU_STATE_RUNNING) {
continue;
        }

// 计算动态优先级（考虑等待时间）
uint32_t dynamic_priority = entity->priority;
uint64_t wait_time = current_time - entity->last_scheduled_time;
if (wait_time > PRIORITY_BOOST_THRESHOLD_NS) {
            dynamic_priority += (wait_time / PRIORITY_BOOST_THRESHOLD_NS);
        }

// 选择优先级最高的实体
if (dynamic_priority > highest_priority) {
            highest_priority = dynamic_priority;
            best_entity = entity;
        }
    }

return best_entity;
}

// 执行调度决策
intgpu_schedule(struct gpu_scheduler *sched) {
structsched_entity *next_entity;
unsignedlong flags;
int ret = 0;

    spin_lock_irqsave(&sched->sched_lock, flags);

// 选择下一个调度实体
    next_entity = select_next_entity(sched);
if (!next_entity) {
// 没有可调度的实体，进入空闲状态
if (sched->current_entity) {
            ret = context_switch_to_idle(sched);
        }
        spin_unlock_irqrestore(&sched->sched_lock, flags);
return ret;
    }

// 检查是否需要上下文切换
if (sched->current_entity != next_entity) {
        ret = perform_context_switch(sched, next_entity);
if (ret) {
            spin_unlock_irqrestore(&sched->sched_lock, flags);
            pr_err("上下文切换失败: %d\n", ret);
return ret;
        }
    }

// 设置抢占定时器
    setup_preemption_timer(sched, next_entity);

    spin_unlock_irqrestore(&sched->sched_lock, flags);
return0;
}

// 执行上下文切换
staticintperform_context_switch(struct gpu_scheduler *sched,
struct sched_entity *next_entity) {
structsched_entity *prev_entity = sched->current_entity;
uint64_t switch_start_time = ktime_get_ns();
int ret;

// 保存当前上下文
if (prev_entity) {
        ret = save_gpu_context(prev_entity->instance);
if (ret) {
            pr_err("保存GPU上下文失败: 实例ID=%u, 错误=%d\n",
                   prev_entity->instance->instance_id, ret);
return ret;
        }

// 更新统计信息
uint64_t execution_time = switch_start_time - sched->current_time_slice_start;
        prev_entity->total_runtime_ns += execution_time;
        prev_entity->remaining_time_ns = (prev_entity->remaining_time_ns > execution_time) ?
                                        (prev_entity->remaining_time_ns - execution_time) : 0;

// 如果时间片用完，重新分配时间片并移到队列末尾
if (prev_entity->remaining_time_ns == 0) {
            prev_entity->remaining_time_ns = prev_entity->time_slice_ns;
            list_move_tail(&prev_entity->sched_list, &sched->ready_queue);
        }
    }

// 恢复新上下文
    ret = restore_gpu_context(next_entity->instance);
if (ret) {
        pr_err("恢复GPU上下文失败: 实例ID=%u, 错误=%d\n",
               next_entity->instance->instance_id, ret);
return ret;
    }

// 更新调度器状态
    sched->current_entity = next_entity;
    sched->current_time_slice_start = ktime_get_ns();

// 更新统计信息
    next_entity->last_scheduled_time = sched->current_time_slice_start;
    next_entity->sched_stats.schedule_count++;
    sched->global_stats.total_context_switches++;

// 从就绪队列移除（正在运行）
    list_del_init(&next_entity->sched_list);

    pr_debug("上下文切换完成: 从实例%u切换到实例%u\n",
             prev_entity ? prev_entity->instance->instance_id : 0,
             next_entity->instance->instance_id);

return0;
}

// 抢占定时器处理函数
staticvoidpreemption_timer_handler(struct timer_list *timer) {
structgpu_scheduler *sched = from_timer(sched, timer, preemption_timer);

// 触发重新调度
    queue_work(sched->sched_wq, &sched->schedule_work);
}

// 调度工作函数
staticvoidschedule_work_handler(struct work_struct *work) {
structgpu_scheduler *sched = container_of(work, struct gpu_scheduler, schedule_work);

    gpu_schedule(sched);
}

5.2.3 上下文管理器（Context Manager）

上下文管理器负责管理多个虚拟GPU实例的执行上下文，包括GPU寄存器状态、内存映射、执行队列等关键信息的保存和恢复。

核心功能：

• • 上下文创建与销毁：为虚拟GPU实例创建独立的执行上下文
• • 状态保存与恢复：在上下文切换时保存和恢复GPU状态
• • 资源隔离：确保不同虚拟GPU实例之间的资源隔离
• • 性能优化：通过增量保存和延迟加载优化切换性能

数据结构设计：

// GPU寄存器状态
structgpu_register_state {
// 通用寄存器
uint32_t general_regs[GPU_GENERAL_REG_COUNT];

// 控制寄存器
uint32_t control_regs[GPU_CONTROL_REG_COUNT];

// 浮点寄存器
uint64_t fp_regs[GPU_FP_REG_COUNT];

// 向量寄存器
uint128_t vector_regs[GPU_VECTOR_REG_COUNT];

// 特殊寄存器
struct {
uint32_t program_counter;       // 程序计数器
uint32_t stack_pointer;         // 栈指针
uint32_t status_register;       // 状态寄存器
uint32_t exception_register;    // 异常寄存器
    } special_regs;

// 内存管理单元状态
struct {
uint64_t page_table_base;       // 页表基址
uint32_t tlb_entries[GPU_TLB_SIZE]; // TLB条目
uint32_t cache_config;          // 缓存配置
    } mmu_state;
};

// 执行队列状态
structgpu_queue_state {
uint32_t queue_id;                  // 队列ID
uint32_t queue_type;                // 队列类型
uint64_t queue_base_addr;           // 队列基地址
uint32_t queue_size;                // 队列大小
uint32_t head_pointer;              // 头指针
uint32_t tail_pointer;              // 尾指针
uint32_t priority;                  // 队列优先级
bool is_active;                     // 是否活跃

// 队列统计信息
struct {
uint64_t submitted_commands;     // 提交的命令数
uint64_t completed_commands;     // 完成的命令数
uint64_t total_execution_time;   // 总执行时间
    } stats;
};

// 虚拟GPU上下文
structvgpu_context {
uint32_t context_id;                // 上下文ID
structvgpu_instance *instance;// 关联的虚拟GPU实例
enumcontext_statestate;// 上下文状态

// GPU状态
structgpu_register_state *reg_state;// 寄存器状态
structgpu_queue_state *queue_states;// 执行队列状态
uint32_t num_queues;                   // 队列数量

// 内存映射
struct {
uint64_t virtual_base;          // 虚拟地址基址
uint64_t physical_base;         // 物理地址基址
uint64_t size;                  // 映射大小
uint32_t permissions;           // 访问权限
    } memory_mappings[MAX_MEMORY_MAPPINGS];
uint32_t num_mappings;              // 映射数量

// 上下文切换优化
struct {
bool dirty_regs[GPU_TOTAL_REG_COUNT]; // 脏寄存器标记
uint64_t last_save_time;        // 上次保存时间
uint64_t last_restore_time;     // 上次恢复时间
uint32_t save_count;            // 保存次数
uint32_t restore_count;         // 恢复次数
    } optimization;

// 同步原语
structmutexcontext_mutex;// 上下文互斥锁
structcompletionsave_completion;// 保存完成信号
structcompletionrestore_completion;// 恢复完成信号

// 链表节点
structlist_headcontext_list;// 上下文链表
};

// 上下文管理器
structcontext_manager {
// 上下文池
structlist_headactive_contexts;// 活跃上下文链表
structlist_headfree_contexts;// 空闲上下文链表
uint32_t max_contexts;              // 最大上下文数
uint32_t active_count;              // 活跃上下文数

// 上下文缓存
structkmem_cache *context_cache;// 上下文内存缓存
structkmem_cache *reg_state_cache;// 寄存器状态缓存

// 性能统计
struct {
uint64_t total_switches;        // 总切换次数
uint64_t total_save_time_ns;    // 总保存时间
uint64_t total_restore_time_ns; // 总恢复时间
uint64_t average_switch_time_ns; // 平均切换时间
    } perf_stats;

// 同步保护
structrw_semaphoremanager_rwsem;// 管理器读写信号量
spinlock_t context_lock;           // 上下文操作锁

// 工作队列
structworkqueue_struct *ctx_wq;// 上下文工作队列
structwork_structcleanup_work;// 清理工作
};

核心操作实现：

// 创建虚拟GPU上下文
struct vgpu_context *vgpu_create_context(struct vgpu_instance *instance) {
structcontext_manager *ctx_mgr = get_context_manager();
structvgpu_context *context;
int ret;

if (!instance) {
        pr_err("无效的虚拟GPU实例\n");
return ERR_PTR(-EINVAL);
    }

// 检查上下文数量限制
    down_read(&ctx_mgr->manager_rwsem);
if (ctx_mgr->active_count >= ctx_mgr->max_contexts) {
        up_read(&ctx_mgr->manager_rwsem);
        pr_warn("已达到最大上下文数限制: %u\n", ctx_mgr->max_contexts);
return ERR_PTR(-ENOSPC);
    }
    up_read(&ctx_mgr->manager_rwsem);

// 分配上下文结构
    context = kmem_cache_alloc(ctx_mgr->context_cache, GFP_KERNEL);
if (!context) {
        pr_err("分配上下文结构失败\n");
return ERR_PTR(-ENOMEM);
    }

// 分配寄存器状态
    context->reg_state = kmem_cache_alloc(ctx_mgr->reg_state_cache, GFP_KERNEL);
if (!context->reg_state) {
        kmem_cache_free(ctx_mgr->context_cache, context);
        pr_err("分配寄存器状态失败\n");
return ERR_PTR(-ENOMEM);
    }

// 分配队列状态数组
    context->queue_states = kcalloc(MAX_GPU_QUEUES, sizeof(struct gpu_queue_state), GFP_KERNEL);
if (!context->queue_states) {
        kmem_cache_free(ctx_mgr->reg_state_cache, context->reg_state);
        kmem_cache_free(ctx_mgr->context_cache, context);
        pr_err("分配队列状态失败\n");
return ERR_PTR(-ENOMEM);
    }

    down_write(&ctx_mgr->manager_rwsem);

// 初始化上下文
    context->context_id = atomic_inc_return(&global_context_id);
    context->instance = instance;
    context->state = CONTEXT_STATE_CREATED;
    context->num_queues = 0;
    context->num_mappings = 0;

// 初始化优化数据
memset(context->optimization.dirty_regs, 0, sizeof(context->optimization.dirty_regs));
    context->optimization.last_save_time = 0;
    context->optimization.last_restore_time = 0;
    context->optimization.save_count = 0;
    context->optimization.restore_count = 0;

// 初始化同步原语
    mutex_init(&context->context_mutex);
    init_completion(&context->save_completion);
    init_completion(&context->restore_completion);

// 添加到活跃上下文列表
    list_add_tail(&context->context_list, &ctx_mgr->active_contexts);
    ctx_mgr->active_count++;

    up_write(&ctx_mgr->manager_rwsem);

    pr_info("创建虚拟GPU上下文成功: ID=%u, 实例ID=%u\n",
            context->context_id, instance->instance_id);

return context;
}

// 保存GPU上下文
intsave_gpu_context(struct vgpu_instance *instance) {
structvgpu_context *context = instance->context;
uint64_t save_start_time = ktime_get_ns();
int ret = 0;

if (!context) {
        pr_err("上下文为空\n");
return -EINVAL;
    }

    mutex_lock(&context->context_mutex);

if (context->state != CONTEXT_STATE_RUNNING) {
        mutex_unlock(&context->context_mutex);
        pr_warn("上下文状态不允许保存: ID=%u, 状态=%d\n",
                context->context_id, context->state);
return -EINVAL;
    }

// 保存通用寄存器（增量保存）
    ret = save_general_registers_incremental(context);
if (ret) {
        mutex_unlock(&context->context_mutex);
        pr_err("保存通用寄存器失败: %d\n", ret);
return ret;
    }

// 保存控制寄存器
    ret = save_control_registers(context);
if (ret) {
        mutex_unlock(&context->context_mutex);
        pr_err("保存控制寄存器失败: %d\n", ret);
return ret;
    }

// 保存浮点和向量寄存器
    ret = save_fp_vector_registers(context);
if (ret) {
        mutex_unlock(&context->context_mutex);
        pr_err("保存浮点向量寄存器失败: %d\n", ret);
return ret;
    }

// 保存MMU状态
    ret = save_mmu_state(context);
if (ret) {
        mutex_unlock(&context->context_mutex);
        pr_err("保存MMU状态失败: %d\n", ret);
return ret;
    }

// 保存执行队列状态
    ret = save_queue_states(context);
if (ret) {
        mutex_unlock(&context->context_mutex);
        pr_err("保存队列状态失败: %d\n", ret);
return ret;
    }

// 更新状态和统计信息
    context->state = CONTEXT_STATE_SAVED;
    context->optimization.last_save_time = ktime_get_ns();
    context->optimization.save_count++;

// 更新全局统计
structcontext_manager *ctx_mgr = get_context_manager();
    ctx_mgr->perf_stats.total_switches++;
    ctx_mgr->perf_stats.total_save_time_ns += 
        (context->optimization.last_save_time - save_start_time);

    mutex_unlock(&context->context_mutex);

// 发送保存完成信号
    complete(&context->save_completion);

    pr_debug("保存GPU上下文完成: ID=%u, 耗时=%llu ns\n",
             context->context_id, 
             context->optimization.last_save_time - save_start_time);

return0;
}

// 恢复GPU上下文
intrestore_gpu_context(struct vgpu_instance *instance) {
structvgpu_context *context = instance->context;
uint64_t restore_start_time = ktime_get_ns();
int ret = 0;

if (!context) {
        pr_err("上下文为空\n");
return -EINVAL;
    }

    mutex_lock(&context->context_mutex);

if (context->state != CONTEXT_STATE_SAVED) {
        mutex_unlock(&context->context_mutex);
        pr_warn("上下文状态不允许恢复: ID=%u, 状态=%d\n",
                context->context_id, context->state);
return -EINVAL;
    }

// 恢复MMU状态（必须首先恢复）
    ret = restore_mmu_state(context);
if (ret) {
        mutex_unlock(&context->context_mutex);
        pr_err("恢复MMU状态失败: %d\n", ret);
return ret;
    }

// 恢复通用寄存器
    ret = restore_general_registers(context);
if (ret) {
        mutex_unlock(&context->context_mutex);
        pr_err("恢复通用寄存器失败: %d\n", ret);
return ret;
    }

// 恢复控制寄存器
    ret = restore_control_registers(context);
if (ret) {
        mutex_unlock(&context->context_mutex);
        pr_err("恢复控制寄存器失败: %d\n", ret);
return ret;
    }

// 恢复浮点和向量寄存器
    ret = restore_fp_vector_registers(context);
if (ret) {
        mutex_unlock(&context->context_mutex);
        pr_err("恢复浮点向量寄存器失败: %d\n", ret);
return ret;
    }

// 恢复执行队列状态
    ret = restore_queue_states(context);
if (ret) {
        mutex_unlock(&context->context_mutex);
        pr_err("恢复队列状态失败: %d\n", ret);
return ret;
    }

// 更新状态和统计信息
    context->state = CONTEXT_STATE_RUNNING;
    context->optimization.last_restore_time = ktime_get_ns();
    context->optimization.restore_count++;

// 清除脏寄存器标记
memset(context->optimization.dirty_regs, 0, sizeof(context->optimization.dirty_regs));

// 更新全局统计
structcontext_manager *ctx_mgr = get_context_manager();
    ctx_mgr->perf_stats.total_restore_time_ns += 
        (context->optimization.last_restore_time - restore_start_time);

    mutex_unlock(&context->context_mutex);

// 发送恢复完成信号
    complete(&context->restore_completion);

    pr_debug("恢复GPU上下文完成: ID=%u, 耗时=%llu ns\n",
             context->context_id,
             context->optimization.last_restore_time - restore_start_time);

return0;
}

// 增量保存通用寄存器（性能优化）
staticintsave_general_registers_incremental(struct vgpu_context *context) {
structgpu_register_state *reg_state = context->reg_state;
uint32_t reg_value;
int saved_count = 0;

// 只保存被修改的寄存器
for (int i = 0; i < GPU_GENERAL_REG_COUNT; i++) {
if (context->optimization.dirty_regs[i]) {
// 读取寄存器值
            reg_value = gpu_read_register(GPU_GENERAL_REG_BASE + i);

// 检查是否真的发生了变化
if (reg_state->general_regs[i] != reg_value) {
                reg_state->general_regs[i] = reg_value;
                saved_count++;
            }

// 清除脏标记
            context->optimization.dirty_regs[i] = false;
        }
    }

    pr_debug("增量保存通用寄存器: 保存了 %d 个寄存器\n", saved_count);
return0;
}

5.2.4 内存管理器（Memory Manager）

内存管理器负责实现GPU内存的虚拟化和隔离，为每个虚拟GPU实例提供独立的内存空间，并确保内存访问的安全性和性能。

核心功能：

• • 内存空间虚拟化：为每个虚拟GPU实例创建独立的虚拟内存空间
• • 内存分配与回收：动态分配和回收GPU内存资源
• • 内存保护与隔离：确保不同实例之间的内存访问隔离
• • 内存映射管理：管理虚拟地址到物理地址的映射关系

数据结构设计：

// 内存区域描述符
structmemory_region {
uint64_t virtual_addr;              // 虚拟地址
uint64_t physical_addr;             // 物理地址
uint64_t size;                      // 区域大小
uint32_t permissions;               // 访问权限
uint32_t flags;                     // 标志位

// 使用统计
struct {
uint64_t allocation_time;       // 分配时间
uint64_t last_access_time;      // 最后访问时间
uint64_t access_count;          // 访问次数
uint64_t bytes_read;            // 读取字节数
uint64_t bytes_written;         // 写入字节数
    } usage_stats;

// 链表节点
structrb_noderb_node;// 红黑树节点
structlist_headregion_list;// 区域链表
};

// 内存页描述符
structmemory_page {
uint64_t physical_addr;             // 物理页地址
uint32_t ref_count;                 // 引用计数
uint32_t flags;                     // 页标志
structvgpu_instance *owner;// 所有者实例

// 页状态
enum {
        PAGE_STATE_FREE,                // 空闲
        PAGE_STATE_ALLOCATED,           // 已分配
        PAGE_STATE_MAPPED,              // 已映射
        PAGE_STATE_SWAPPED,             // 已交换
    } state;

// 链表节点
structlist_headpage_list;// 页链表
structhlist_nodehash_node;// 哈希表节点
};

// 虚拟GPU内存空间
structvgpu_memory_space {
uint32_t space_id;                  // 内存空间ID
structvgpu_instance *instance;// 关联的虚拟GPU实例

// 地址空间布局
struct {
uint64_t virtual_base;          // 虚拟地址空间基址
uint64_t virtual_size;          // 虚拟地址空间大小
uint64_t heap_base;             // 堆基址
uint64_t heap_size;             // 堆大小
uint64_t stack_base;            // 栈基址
uint64_t stack_size;            // 栈大小
    } layout;

// 内存区域管理
structrb_rootregion_tree;// 内存区域红黑树
structlist_headregion_list;// 内存区域链表
uint32_t region_count;              // 区域数量

// 页表管理
struct {
uint64_t *page_table;           // 页表指针
uint32_t page_table_levels;     // 页表级数
uint64_t page_table_size;       // 页表大小
structmemory_page **pages;// 页描述符数组
uint32_t total_pages;           // 总页数
uint32_t allocated_pages;       // 已分配页数
    } page_mgmt;

// 内存统计
struct {
uint64_t total_allocated;       // 总分配内存
uint64_t peak_usage;            // 峰值使用量
uint64_t current_usage;         // 当前使用量
uint32_t allocation_count;      // 分配次数
uint32_t deallocation_count;    // 释放次数
uint64_t fragmentation_ratio;   // 碎片率
    } memory_stats;

// 同步保护
structrw_semaphorespace_rwsem;// 内存空间读写信号量
spinlock_t region_lock;            // 区域操作锁
structmutexpage_mutex;// 页操作互斥锁
};

// GPU内存管理器
structgpu_memory_manager {
// 物理内存池
struct {
uint64_t total_memory;          // 总内存大小
uint64_t available_memory;      // 可用内存大小
uint64_t reserved_memory;       // 保留内存大小
structlist_headfree_pages;// 空闲页链表
structmemory_page *page_array;// 页描述符数组
uint32_t total_pages;           // 总页数
uint32_t free_pages_count;      // 空闲页数
    } physical_pool;

// 虚拟内存空间管理
structlist_headmemory_spaces;// 内存空间链表
structidrspace_idr;// 内存空间ID分配器
uint32_t active_spaces;            // 活跃空间数
uint32_t max_spaces;               // 最大空间数

// 内存分配策略
enum {
        ALLOC_STRATEGY_FIRST_FIT,       // 首次适应
        ALLOC_STRATEGY_BEST_FIT,        // 最佳适应
        ALLOC_STRATEGY_WORST_FIT,       // 最坏适应
        ALLOC_STRATEGY_BUDDY,           // 伙伴系统
    } allocation_strategy;

// 内存回收
struct {
structworkqueue_struct *gc_wq;// 垃圾回收工作队列
structdelayed_workgc_work;// 垃圾回收工作
uint64_t gc_threshold;          // 回收阈值
uint32_t gc_interval_ms;        // 回收间隔
    } garbage_collector;

// 全局统计
struct {
uint64_t total_allocations;     // 总分配次数
uint64_t total_deallocations;   // 总释放次数
uint64_t allocation_failures;   // 分配失败次数
uint64_t peak_memory_usage;     // 峰值内存使用
float average_fragmentation;    // 平均碎片率
    } global_stats;

// 同步保护
structrw_semaphoremanager_rwsem;// 管理器读写信号量
spinlock_t pool_lock;              // 内存池锁
};

核心操作实现：

// 分配GPU内存
void *vgpu_memory_alloc(struct vgpu_memory_space *space, uint64_t size, uint32_t alignment) {
structgpu_memory_manager *mem_mgr = get_memory_manager();
structmemory_region *region;
uint64_t aligned_size;
uint64_t virtual_addr;
int ret;

if (!space || size == 0) {
        pr_err("无效的参数\n");
return ERR_PTR(-EINVAL);
    }

// 对齐大小
    aligned_size = ALIGN(size, alignment ? alignment : PAGE_SIZE);

    down_write(&space->space_rwsem);

// 检查内存配额
if (space->memory_stats.current_usage + aligned_size > 
        space->instance->resource_quota.memory_quota) {
        up_write(&space->space_rwsem);
        pr_warn("内存配额不足: 请求=%llu, 当前使用=%llu, 配额=%llu\n",
                aligned_size, space->memory_stats.current_usage,
                space->instance->resource_quota.memory_quota);
return ERR_PTR(-ENOMEM);
    }

// 查找合适的虚拟地址
    virtual_addr = find_free_virtual_address(space, aligned_size, alignment);
if (virtual_addr == 0) {
        up_write(&space->space_rwsem);
        pr_err("无法找到合适的虚拟地址\n");
return ERR_PTR(-ENOMEM);
    }

// 分配物理页
    ret = allocate_physical_pages(mem_mgr, space, virtual_addr, aligned_size);
if (ret) {
        up_write(&space->space_rwsem);
        pr_err("分配物理页失败: %d\n", ret);
return ERR_PTR(ret);
    }

// 创建内存区域描述符
    region = create_memory_region(space, virtual_addr, aligned_size);
if (IS_ERR(region)) {
        free_physical_pages(mem_mgr, space, virtual_addr, aligned_size);
        up_write(&space->space_rwsem);
        pr_err("创建内存区域失败\n");
return region;
    }

// 建立虚拟到物理地址映射
    ret = setup_memory_mapping(space, region);
if (ret) {
        destroy_memory_region(space, region);
        free_physical_pages(mem_mgr, space, virtual_addr, aligned_size);
        up_write(&space->space_rwsem);
        pr_err("建立内存映射失败: %d\n", ret);
return ERR_PTR(ret);
    }

// 更新统计信息
    space->memory_stats.current_usage += aligned_size;
    space->memory_stats.total_allocated += aligned_size;
    space->memory_stats.allocation_count++;

if (space->memory_stats.current_usage > space->memory_stats.peak_usage) {
        space->memory_stats.peak_usage = space->memory_stats.current_usage;
    }

    up_write(&space->space_rwsem);

    pr_debug("分配GPU内存成功: 虚拟地址=0x%llx, 大小=%llu\n", virtual_addr, aligned_size);

return (void *)virtual_addr;
}

// 释放GPU内存
intvgpu_memory_free(struct vgpu_memory_space *space, void *ptr) {
structgpu_memory_manager *mem_mgr = get_memory_manager();
structmemory_region *region;
uint64_t virtual_addr = (uint64_t)ptr;
int ret = 0;

if (!space || !ptr) {
        pr_err("无效的参数\n");
return -EINVAL;
    }

    down_write(&space->space_rwsem);

// 查找内存区域
    region = find_memory_region(space, virtual_addr);
if (!region) {
        up_write(&space->space_rwsem);
        pr_warn("未找到内存区域: 虚拟地址=0x%llx\n", virtual_addr);
return -ENOENT;
    }

// 检查地址是否为区域起始地址
if (region->virtual_addr != virtual_addr) {
        up_write(&space->space_rwsem);
        pr_warn("地址不是区域起始地址: 虚拟地址=0x%llx, 区域起始=0x%llx\n",
                virtual_addr, region->virtual_addr);
return -EINVAL;
    }

// 移除内存映射
    ret = remove_memory_mapping(space, region);
if (ret) {
        up_write(&space->space_rwsem);
        pr_err("移除内存映射失败: %d\n", ret);
return ret;
    }

// 释放物理页
    ret = free_physical_pages(mem_mgr, space, region->virtual_addr, region->size);
if (ret) {
        pr_err("释放物理页失败: %d\n", ret);
// 继续执行，不返回错误
    }

// 更新统计信息
    space->memory_stats.current_usage -= region->size;
    space->memory_stats.deallocation_count++;

// 销毁内存区域
    destroy_memory_region(space, region);

    up_write(&space->space_rwsem);

    pr_debug("释放GPU内存成功: 虚拟地址=0x%llx\n", virtual_addr);

return0;
}

// 检查内存访问权限
intcheck_memory_access_permission(struct vgpu_memory_space *space, 
uint64_t virtual_addr, uint64_t size, 
uint32_t access_type) {
structmemory_region *region;
uint64_t end_addr = virtual_addr + size;

    down_read(&space->space_rwsem);

// 查找覆盖访问范围的所有内存区域
    region = find_memory_region_range(space, virtual_addr, end_addr);
while (region) {
// 检查访问权限
if ((region->permissions & access_type) != access_type) {
            up_read(&space->space_rwsem);
            pr_warn("内存访问权限不足: 地址=0x%llx, 权限=0x%x, 需要=0x%x\n",
                    virtual_addr, region->permissions, access_type);
return -EACCES;
        }

// 更新访问统计
        region->usage_stats.last_access_time = ktime_get_ns();
        region->usage_stats.access_count++;

if (access_type & MEMORY_ACCESS_READ) {
            region->usage_stats.bytes_read += size;
        }
if (access_type & MEMORY_ACCESS_WRITE) {
            region->usage_stats.bytes_written += size;
        }

// 查找下一个区域
        virtual_addr = region->virtual_addr + region->size;
if (virtual_addr >= end_addr) {
break;
        }
        region = find_memory_region_range(space, virtual_addr, end_addr);
    }

    up_read(&space->space_rwsem);
return0;
}

上下文切换机制：

虚拟GPU上下文切换是内核态虚拟化的核心技术，需要保存和恢复GPU的完整执行状态。

// 虚拟GPU上下文结构定义
structvgpu_context {
uint32_t context_id;               // 上下文标识符
uint32_t vgpu_id;                  // 所属虚拟GPU ID

// GPU寄存器状态
struct {
uint32_t *general_registers;    // 通用寄存器
uint32_t *special_registers;    // 特殊寄存器
uint64_t program_counter;       // 程序计数器
uint32_t status_register;       // 状态寄存器
    } gpu_state;

// 内存映射信息
struct {
uint64_t *page_table;           // 页表基址
uint32_t memory_segments;       // 内存段数量
structmemory_mapping *mappings;// 内存映射列表
    } memory_state;

// 调度信息
struct {
uint32_t priority;              // 调度优先级
uint64_t time_slice;            // 时间片
uint64_t execution_time;        // 累计执行时间
uint32_t preemption_count;      // 抢占次数
    } sched_info;
};

// 虚拟GPU上下文切换实现
intvgpu_context_switch(struct vgpu_device *vgpu, 
struct vgpu_context *old_ctx, 
struct vgpu_context *new_ctx) {
unsignedlong flags;
int ret = 0;

// 获取GPU访问锁
    spin_lock_irqsave(&vgpu->gpu_lock, flags);

// 保存当前上下文状态
if (old_ctx) {
        ret = save_gpu_context(vgpu, old_ctx);
if (ret) {
            pr_err("保存GPU上下文失败: %d\n", ret);
goto unlock;
        }

// 更新统计信息
        old_ctx->sched_info.preemption_count++;
        update_execution_time(old_ctx);
    }

// 加载新上下文
if (new_ctx) {
        ret = restore_gpu_context(vgpu, new_ctx);
if (ret) {
            pr_err("恢复GPU上下文失败: %d\n", ret);
goto unlock;
        }

// 更新调度信息
        update_scheduling_priority(new_ctx);
        start_execution_timer(new_ctx);
    }

unlock:
    spin_unlock_irqrestore(&vgpu->gpu_lock, flags);
return ret;
}