HIP与CUDA对照
上一章说 HIP 和 CUDA 长得几乎一样。但**"几乎"里的差异**才是真正会踩坑的地方。这一章把 HIP 和 CUDA 的对应关系摊开,逐一讲清楚——哪些是一模一样的、哪些是名字变了、哪些是语义完全不同的。
看完这一章你能做到:打开一段 CUDA 代码就能想象出它的 HIP 版本长什么样。
1. 完全相同的东西
以下这些语法和语义完全一样——CUDA 怎么写、HIP 就怎么写:
Kernel 修饰符:
__global__ // 从 host 调用、在 device 执行
__device__ // 从 device 调用、在 device 执行
__host__ // 从 host 调用、在 host 执行
内存修饰符:
__shared__ // 共享内存
__constant__ // 常量内存
Kernel 启动语法:
kernel<<<grid, block>>>(args...);
kernel<<<grid, block, shmem_bytes>>>(args...);
kernel<<<grid, block, shmem_bytes, stream>>>(args...);
内置变量:
threadIdx.x, threadIdx.y, threadIdx.z
blockIdx.x, blockIdx.y, blockIdx.z
blockDim.x, blockDim.y, blockDim.z
gridDim.x, gridDim.y, gridDim.z
同步:
__syncthreads();
__threadfence();
__threadfence_block();
基础数学:所有 sinf、cosf、sqrtf、__sinf、__cosf 等 CUDA 里的 device 函数在 HIP 里都有。
2. 名字前缀变换:cuda* → hip*
这是最主要的转换规则。运行时 API 里几乎所有 cuda* 都对应一个 hip*:
// CUDA
cudaMalloc(&d_ptr, N);
cudaMemcpy(d_ptr, h_ptr, N, cudaMemcpyHostToDevice);
cudaFree(d_ptr);
cudaDeviceSynchronize();
cudaGetLastError();
// HIP
hipMalloc(&d_ptr, N);
hipMemcpy(d_ptr, h_ptr, N, hipMemcpyHostToDevice);
hipFree(d_ptr);
hipDeviceSynchronize();
hipGetLastError();
常量枚举也一样:
cudaSuccess → hipSuccess
cudaMemcpyHostToDevice → hipMemcpyHostToDevice
cudaMemcpyDeviceToHost → hipMemcpyDeviceToHost
cudaStreamNonBlocking → hipStreamNonBlocking
结构体也一样:
cudaDeviceProp → hipDeviceProp_t
cudaStream_t → hipStream_t
cudaEvent_t → hipEvent_t
规则简单:前缀替换就完事。90% 的转换是机械的。
3. Warp / Wavefront:最大的差异
前一章提过——AMD 的 wavefront 通常是 64,NVIDIA 的 warp 是 32。
这个差异会体现在几个地方:
warpSize:
// CUDA: warpSize == 32 always
// HIP on NVIDIA: warpSize == 32
// HIP on AMD (CDNA): warpSize == 64
// HIP on AMD (RDNA, wave32): warpSize == 32
永远用 warpSize 而不是硬编码 32:
// 坏:假设 warp 是 32
for (int offset = 16; offset > 0; offset /= 2) { ... }
// 好:用 warpSize 表达
for (int offset = warpSize / 2; offset > 0; offset /= 2) { ... }
Shuffle 的 mask 类型:
// CUDA
__shfl_down_sync(0xffffffff, val, offset); // 32-bit mask
// HIP on AMD (wave64)
__shfl_down(val, offset); // 无 mask 参数
// 或者用 __shfl_down_sync(0xffffffffffffffff, val, offset); // 64-bit
Ballot 的返回类型:
// CUDA: unsigned int (32-bit)
unsigned mask = __ballot_sync(0xffffffff, cond);
// HIP on AMD (wave64): unsigned long long (64-bit)
unsigned long long mask = __ballot(cond);
规则:写 HIP 代码时假设 wavefront 可能是 64,用 warpSize 表达一切。
4. 编译器与 arch flag
CUDA:
nvcc -arch=sm_80 my_code.cu -o my_program
HIP:
hipcc --offload-arch=gfx90a my_code.cpp -o my_program # MI200
hipcc --offload-arch=gfx942 my_code.cpp -o my_program # MI300
gfx 编号对照:
| 硬件 | gfx 号 |
|---|---|
| Vega 20(MI50/MI60) | gfx906 |
| CDNA1(MI100) | gfx908 |
| CDNA2(MI250) | gfx90a |
| CDNA3(MI300) | gfx942 |
| RDNA2(RX 6000) | gfx1030, gfx1031, ... |
| RDNA3(RX 7000) | gfx1100, gfx1101, ... |
多个 arch 一起编:
hipcc --offload-arch=gfx90a --offload-arch=gfx942 my_code.cpp
编出来的 binary 里包含多个架构的机器码,运行时选合适的。
5. Streams、Events、Async
几乎完全一样:
hipStream_t stream;
hipStreamCreate(&stream);
hipStreamCreateWithFlags(&stream, hipStreamNonBlocking);
hipEvent_t event;
hipEventCreate(&event);
hipEventRecord(event, stream);
hipEventSynchronize(event);
hipMemcpyAsync(dst, src, N, hipMemcpyHostToDevice, stream);
hipStreamSynchronize(stream);
Pinned memory:
// CUDA: cudaMallocHost
hipHostMalloc(&h_ptr, N);
(注意 CUDA 用 cudaMallocHost 或 cudaHostAlloc,HIP 统一用 hipHostMalloc)
6. 数学库对应
| CUDA 库 | HIP / ROCm 对应 |
|---|---|
| cuBLAS | rocBLAS 或 hipBLAS |
| cuDNN | MIOpen |
| cuFFT | rocFFT 或 hipFFT |
| cuSPARSE | rocSPARSE 或 hipSPARSE |
| cuRAND | rocRAND 或 hipRAND |
| Thrust | rocThrust |
| CUB | hipCUB / rocPRIM |
| NCCL | RCCL |
| TensorRT | 无直接对应(用 MIGraphX 或 vLLM 等) |
| CUTLASS | Composable Kernel (CK) |
hipXXX vs rocXXX 的区别:
- rocBLAS 是 AMD 原生 API——用它写代码只能跑 AMD;
- hipBLAS 是"跨平台包装"——底层可能调 cuBLAS 或 rocBLAS,取决于目标平台。
规则:写跨平台代码用 hipBLAS/hipFFT,写只跑 AMD 的高性能代码可以直接用 rocBLAS/rocFFT。
7. Tensor Core / Matrix Core
CUDA 的 WMMA API:
#include <mma.h>
using namespace nvcuda::wmma;
fragment<matrix_a, 16, 16, 16, half, row_major> a_frag;
fragment<matrix_b, 16, 16, 16, half, col_major> b_frag;
fragment<accumulator, 16, 16, 16, float> c_frag;
load_matrix_sync(a_frag, A, K);
load_matrix_sync(b_frag, B, N);
mma_sync(c_frag, a_frag, b_frag, c_frag);
store_matrix_sync(C, c_frag, N, mem_row_major);
AMD 上没有直接对应的 WMMA API——用内建 __builtin_amdgcn_mfma_* 或者Composable Kernel 库:
// Direct MFMA intrinsic
using floatx16 = float __attribute__((ext_vector_type(16)));
floatx16 c = {0};
c = __builtin_amdgcn_mfma_f32_16x16x16bf16_1k(a, b, c, 0, 0, 0);
MFMA 的 tile 尺寸和 NVIDIA 的 WMMA 不太一样——MI300 有 16x16x16、16x16x32、32x32x8 等多种。直接迁移不能一一对应,需要重新设计。
深度学习框架级别:PyTorch / TF 已经把这层封装好了——你写 torch.matmul(a, b),会自动用 Matrix Core。不用手写 MFMA。
8. 特殊指令的对应
Warp shuffle:
// CUDA
val = __shfl_sync(mask, val, srcLane);
val = __shfl_down_sync(mask, val, delta);
val = __shfl_up_sync(mask, val, delta);
val = __shfl_xor_sync(mask, val, laneMask);
// HIP (AMD)
val = __shfl(val, srcLane);
val = __shfl_down(val, delta);
val = __shfl_up(val, delta);
val = __shfl_xor(val, laneMask);
(HIP 的 _sync 版本存在但 mask 语义略不同——在 CDNA 上 mask 参数被忽略,因为 wavefront 天然同步)
Atomic:几乎完全一样:
atomicAdd(&x, val);
atomicMin(&x, val);
atomicMax(&x, val);
atomicCAS(&x, expected, val);
Cooperative Groups:
// CUDA
#include <cooperative_groups.h>
namespace cg = cooperative_groups;
// HIP
#include <hip/hip_cooperative_groups.h>
namespace cg = cooperative_groups;
基本一致,但有些高级用法(grid_group::sync() 等)在 HIP 上支持不完整。
9. Profiler 与调试工具
| CUDA 工具 | ROCm 对应 |
|---|---|
nvcc | hipcc |
nvprof (deprecated) | rocprof (deprecated → omnitrace) |
| Nsight Systems | omnitrace / rocprof-trace-decoder |
| Nsight Compute | rocprof + omniperf |
cuda-gdb | rocgdb |
cuda-memcheck | rocm-compute-viewer |
nvidia-smi | rocm-smi |
omniperf / omnitrace 是 AMD 相对新的分析工具——功能开始追上 Nsight,但生态成熟度仍有差距。
10. 条件编译
写"同时支持 CUDA 和 HIP"的代码时经常要区分平台:
#ifdef __CUDACC__
// CUDA 编译器
#include <cuda_runtime.h>
#include <cub/cub.cuh>
#elif defined(__HIPCC__)
// HIP 编译器
#include <hip/hip_runtime.h>
#include <hipcub/hipcub.hpp>
#endif
#ifdef __CUDA_ARCH__
// NVIDIA GPU 上
#endif
#ifdef __HIP_DEVICE_COMPILE__
// AMD GPU 上编译时
#endif
这种条件编译能让一份代码适配两个平台。很多 HPC 和深度学习库(PyTorch、vLLM、SGLang)内部大量用这种模式。
11. 一个具体的例子:warp 归约
CUDA 版本:
__device__ float warp_reduce_sum(float val) {
for (int offset = warpSize / 2; offset > 0; offset /= 2) {
val += __shfl_down_sync(0xffffffff, val, offset);
}
return val;
}
HIP 版本(wave64 兼容):
__device__ float warp_reduce_sum(float val) {
for (int offset = warpSize / 2; offset > 0; offset /= 2) {
val += __shfl_down(val, offset); // 无 mask
}
return val;
}
跨平台版本:
__device__ float warp_reduce_sum(float val) {
for (int offset = warpSize / 2; offset > 0; offset /= 2) {
#ifdef __CUDA_ARCH__
val += __shfl_down_sync(0xffffffff, val, offset);
#else
val += __shfl_down(val, offset);
#endif
}
return val;
}
注意:因为循环用 warpSize,wavefront 是 32 还是 64 都自动适配。这是好的写法。
12. 一些"看似能对应但要小心"的情况
Block size 上限:CUDA 上是 1024,HIP 在 AMD 上也是 1024。一致。
Grid size 上限:都是 2^31 - 1,一致。
Shared memory 大小:CUDA A100 每 SM 164KB、HIP MI200 每 CU 64KB——要动态查询:hipDeviceProp_t.sharedMemPerBlock。
Constant memory:CUDA 是 64KB、AMD 是 32-64KB 具体看架构。跨平台代码要 defensive。
Occupancy 计算:hipOccupancyMaxActiveBlocksPerMultiprocessor 和 CUDA 完全对应,接口一样。
13. 从 CUDA 到 HIP 的实操步骤
如果你有一个 CUDA 项目,迁移到 HIP 的实操步骤:
Step 1:跑 hipify-perl 或 hipify-clang 做初步转换:
hipify-perl src/*.cu > src.hip.cpp
Step 2:手动 review 转换结果。看 warning 提示的地方——通常是 warp intrinsic、纹理、cuBLAS 特殊用法。
Step 3:修 wavefront 相关的代码——把硬编码 32 改成 warpSize,把 32-bit mask 改成 64-bit 或者用无 mask 版本。
Step 4:换 library——cuBLAS → hipBLAS、cuDNN → MIOpen、Thrust → rocThrust。
Step 5:调整编译系统——CMake 里加 find_package(hip)、target_link_libraries(... hip::device)。
Step 6:测试。先测正确性(结果和 CUDA 版一致)再测性能(可能需要针对 AMD 特性调优)。
Step 7:性能调优——用 rocprof、omniperf 找瓶颈,调整 wavefront-level 代码、shared memory 布局等。
14. 一句话总结
HIP 和 CUDA 的对照可以总结成几条:
- 90% 完全对应:
cuda*→hip*,语法一致; - 主要差异:wavefront 64 vs warp 32,warp-level 代码要用
warpSize; - 数学库需要换:cuBLAS → hipBLAS/rocBLAS 等;
- Tensor Core → Matrix Core:概念一致,接口不同;
- 工具生态:nsys/ncu → omnitrace/omniperf;
- 条件编译用
__CUDA_ARCH__或__HIP_DEVICE_COMPILE__分开处理。
写好一份能跨平台的 HIP 代码,比起"锁死 CUDA",长远看是划算的投资——未来的 GPU 世界一定会更多元。
下一章我们深入 AMD GPU 的硬件特色——Wavefront 和 CU(Compute Unit),这些是理解 HIP 性能特性的基础。