AMD HIP Runtime概览

一、HIP 生态系统概览

1.1 HIP 核心组件架构

HIP 生态系统
├── HIP Runtime (核心运行时)          ← 本文档重点
├── HIP Compiler (hipcc/hip-clang)
├── HIP Libraries (rocBLAS, rocFFT等)
├── HIP Tools (rocprof, rocgdb等)
└── HIP Porting Tools (hipify-perl等)

1.2 HIP Runtime 在系统中的位置

应用程序
    ↓
HIP API (C/C++接口)
    ↓
HIP Runtime (运行时库)
    ↓
ROCm 驱动层
    ↓
AMD GPU 硬件

二、HIP Runtime 学习内容（按重要性排序）

第1级：核心基础（必须掌握）

1.1 设备管理与初始化

// 核心API
hipGetDeviceCount(&count);          // 设备数量查询
hipSetDevice(device_id);            // 设备选择
hipGetDevice(&current_device);      // 当前设备获取
hipDeviceGetAttribute(...);         // 设备属性查询
hipDeviceSynchronize();             // 设备同步
hipGetLastError();                  // 错误检查

学习要点：

• 设备发现与选择策略
• 设备属性理解（计算能力、内存等）
• 错误处理模式
• 多设备环境初始化

1.2 内存管理基础

// 主机-设备内存管理
hipMalloc(&d_ptr, size);            // 设备内存分配
hipFree(d_ptr);                     // 设备内存释放
hipMallocHost(&h_ptr, size);        // 主机锁页内存
hipFreeHost(h_ptr);

// 数据传输
hipMemcpy(dst, src, size, kind);    // 同步拷贝
hipMemcpyAsync(...);                // 异步拷贝
hipMemcpyKind:                      // 拷贝类型
    hipMemcpyHostToDevice
    hipMemcpyDeviceToHost
    hipMemcpyDeviceToDevice

学习要点：

• 内存分配与释放的生命周期管理
• 同步 vs 异步内存传输
• 锁页内存的优势与使用
• 内存拷贝方向与性能影响

1.3 内核执行基础

// 内核启动
hipLaunchKernelGGL(kernel_name,     // 内核函数
                   dim3(grid),      // 网格维度
                   dim3(block),     // 线程块维度
                   shared_mem,      // 共享内存大小
                   stream,          // 执行流
                   args...);        // 内核参数

// 内核函数定义
__global__ void kernel_name(args) {
    // 内核代码
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
}

学习要点：

• 网格与线程块配置原则
• 内核参数传递机制
• 线程索引计算模式
• 内核编译与链接

第2级：性能关键（重要掌握）

2.1 流与异步执行

// 流管理
hipStream_t stream;
hipStreamCreate(&stream);           // 创建流
hipStreamDestroy(stream);           // 销毁流
hipStreamSynchronize(stream);       // 流同步

// 异步操作
hipMemcpyAsync(dst, src, size, kind, stream);
hipMemsetAsync(ptr, value, size, stream);
hipLaunchKernelGGL(..., stream);

// 默认流
hipStream_t default_stream = 0;     // 默认流标识

学习要点：

• 流的并发执行原理
• 异步操作重叠计算与传输
• 默认流与自定义流的区别
• 流同步的正确使用

2.2 事件与计时

// 事件管理
hipEvent_t start, stop;
hipEventCreate(&start);
hipEventCreate(&stop);

// 事件记录与计时
hipEventRecord(start, stream);
// ... 执行操作 ...
hipEventRecord(stop, stream);
hipEventSynchronize(stop);

float elapsed_ms;
hipEventElapsedTime(&elapsed_ms, start, stop);

学习要点：

• 精确性能测量
• 操作间依赖关系管理
• 事件同步机制
• 性能分析基础

2.3 共享内存与同步

// 共享内存使用
__global__ void kernel() {
    __shared__ float shared_mem[1024];  // 静态共享内存
    extern __shared__ int dynamic_shared[]; // 动态共享内存
    
    // 线程块内同步
    __syncthreads();
    
    // 内存栅栏
    __threadfence();
    __threadfence_block();
}

学习要点：

• 共享内存的 bank 冲突避免
• 线程块同步的正确使用
• 静态 vs 动态共享内存
• 内存一致性模型

第3级：高级特性（需要了解）

3.1 统一内存管理

// 统一内存分配
hipMallocManaged(&ptr, size, hipMemAttachGlobal);

// 内存预取
hipMemPrefetchAsync(ptr, size, device_id, stream);

// 访问建议
hipMemAdvise(ptr, size, advice, device_id);
hipMemAdviseSetAccessedBy:    // 访问建议类型
hipMemAdviseSetReadMostly:
hipMemAdviseSetPreferredLocation:

学习要点：

• 统一内存的自动迁移机制
• 预取策略优化
• 访问模式提示
• 多设备统一内存管理

3.2 图执行

// 图创建与执行
hipGraph_t graph;
hipGraphCreate(&graph, 0);

// 添加节点
hipGraphNode_t node;
hipGraphAddKernelNode(&node, graph, dependencies, num_deps, &params);

// 图实例化与启动
hipGraphExec_t graph_exec;
hipGraphInstantiate(&graph_exec, graph, NULL, NULL, 0);
hipGraphLaunch(graph_exec, stream);

学习要点：

• 图执行的优势（启动开销低）
• 图节点类型（内核、内存、空节点）
• 图更新机制
• 适用场景分析

3.3 内存池

// 内存池创建
hipMemPoolProps props = {};
props.allocType = hipMemAllocationTypePinned;
props.location.type = hipMemLocationTypeDevice;
props.location.id = device_id;

hipMemPool_t mem_pool;
hipMemPoolCreate(&mem_pool, &props);

// 从内存池分配
hipMallocFromPoolAsync(&ptr, size, mem_pool, stream);

学习要点：

• 内存池的性能优势
• 内存重用策略
• 内存池属性配置
• 异步分配机制

第4级：系统级特性（扩展知识）

4.1 多设备编程

// 设备间对等访问
int can_access = 0;
hipDeviceCanAccessPeer(&can_access, dev0, dev1);
if (can_access) {
    hipDeviceEnablePeerAccess(dev1, 0);
}

// 设备间内存拷贝
hipMemcpyPeer(dst, dst_dev, src, src_dev, size);

// 多设备工作分配
#pragma omp parallel for
for (int dev = 0; dev < num_devices; dev++) {
    hipSetDevice(dev);
    // 设备特定工作
}

学习要点：

• 对等访问的条件与限制
• 多设备负载均衡策略
• 设备间通信优化
• NUMA 感知编程

4.2 协作组

#include <cooperative_groups.h>
using namespace cooperative_groups;

__global__ void kernel() {
    // 线程块组
    auto block = this_thread_block();
    block.sync();
    
    // 网格组（需要特殊启动）
    auto grid = this_grid();
    grid.sync();
    
    // 分区组
    auto tile = tiled_partition<32>(block);
}

学习要点：

• 协作组的同步机制
• 网格同步的特殊要求
• 线程块分区模式
• 协作函数使用

4.3 资源查询与限制

// 资源查询
size_t free, total;
hipMemGetInfo(&free, &total);        // 内存信息

int max_threads;
hipDeviceGetAttribute(&max_threads, 
                     hipDeviceAttributeMaxThreadsPerBlock, 
                     device);

// 资源限制设置
hipDeviceSetLimit(hipLimitMallocHeapSize, size);
hipDeviceSetLimit(hipLimitStackSize, size);

学习要点：

• 运行时资源监控
• 设备能力查询
• 资源限制配置
• 自适应编程策略

三、API 分类速查表

核心 API 类别

类别	关键函数前缀	重要性	使用频率
设备管理	hipGetDevice*, hipSetDevice*	★★★★★	高
内存管理	hipMalloc*, hipMemcpy*, hipFree*	★★★★★	高
内核执行	hipLaunchKernelGGL	★★★★★	高
流管理	hipStream*	★★★★☆	高
事件管理	hipEvent*	★★★★☆	中
错误处理	hipGetLastError, hipGetErrorString	★★★★☆	高
同步操作	hipDeviceSynchronize, hipStreamSynchronize	★★★★☆	高

高级 API 类别

类别	关键函数前缀	重要性	使用场景
统一内存	hipMallocManaged, hipMemPrefetch*	★★★☆☆	简化内存管理
图执行	hipGraph*, hipGraphExec*	★★★☆☆	重复执行模式
内存池	hipMemPool*	★★☆☆☆	高性能应用
协作组	cooperative_groups::	★★☆☆☆	高级同步
对等访问	hipDeviceCanAccessPeer, hipMemcpyPeer	★★☆☆☆	多 GPU 应用

四、学习资源对应

官方文档重点章节

1. HIP Runtime API Reference - 所有 API 详细说明
2. HIP Programming Guide - 编程模型和最佳实践
3. HIP Porting Guide - CUDA 到 HIP 的移植指南
4. ROCm Documentation - 系统级配置和工具

实践代码库

# HIP 示例代码
/opt/rocm/share/hip/samples/  # 安装后的示例
https://github.com/ROCm/hip-samples  # GitHub 仓库

# 关键示例
0_Intro/hipInfo.cpp          # 设备信息查询
1_Utils/hipMemcpy.cpp        # 内存拷贝示例
2_Cookbook/1_hipEvent/       # 事件计时示例
3_Streams/                   # 流管理示例

五、重要性总结

必须精通（日常工作基础）

1. 设备初始化与选择
2. 内存分配与数据传输
3. 内核启动与配置
4. 错误检查与处理
5. 流与异步编程

需要熟练（性能优化关键）

1. 事件计时与同步
2. 共享内存优化
3. 内存访问模式
4. 执行配置优化
5. 统一内存管理

应当了解（高级应用需要）

1. 图执行模式
2. 内存池管理
3. 多设备编程
4. 协作组同步
5. 资源限制管理

可选扩展（特定场景）

1. 纹理/表面内存
2. 动态并行
3. 原子操作优化
4. Warp 级编程
5. 硬件特性利用

这个学习内容文档按照重要性排序，你可以从核心基础开始，逐步深入到高级特性。每个部分都包含了关键的 API 和概念，适合软件工程师系统学习 HIP Runtime。