跳到主要内容

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 对应
cuBLASrocBLAS 或 hipBLAS
cuDNNMIOpen
cuFFTrocFFT 或 hipFFT
cuSPARSErocSPARSE 或 hipSPARSE
cuRANDrocRAND 或 hipRAND
ThrustrocThrust
CUBhipCUB / rocPRIM
NCCLRCCL
TensorRT无直接对应(用 MIGraphX 或 vLLM 等)
CUTLASSComposable 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 对应
nvcchipcc
nvprof (deprecated)rocprof (deprecated → omnitrace)
Nsight Systemsomnitrace / rocprof-trace-decoder
Nsight Computerocprof + omniperf
cuda-gdbrocgdb
cuda-memcheckrocm-compute-viewer
nvidia-smirocm-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 性能特性的基础。