Skip to main content
skill CX Codex

hip-rocm — Claude Code skill: HIP and installation

hip-rocm is a Claude Code skill for writing HIP kernels and moving CUDA code to AMD GPUs. It activates for HIP, ROCm, HIPIFY, profiling, and debugging tasks.

MIT 364 installs ★ 298 updated 2026-06-27

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add mohitmishra786/low-level-dev-skills --skill hip-rocm -a claude-code
Open on GitHub

What hip-rocm does

hip-rocm guides agents through ROCm setup, HIP compilation with hipcc, and CUDA-to-HIP conversion using hipify-perl or hipify-clang. It includes CUDA-to-HIP API mappings plus command examples for rocprof profiling and rocgdb debugging.

For MI300X, the skill covers the gfx942 target, MFMA instructions, and 64-thread wavefronts. Its ROCm setup examples target Linux systems with MI200 or MI300 hardware. The workflows use ROCm tools such as rocminfo, rocm-smi, and hipcc.

What it helps with

  • set up ROCm for AMD GPU development
  • write and compile a HIP kernel with hipcc
  • convert CUDA code with HIPIFY
  • profile a HIP application with rocprof
  • debug a device fault using rocgdb

Example prompts for the agent

  • Port this CUDA project to AMD GPUs with HIPIFY.
  • Write a HIP vector-add kernel and compile it with hipcc.
  • Show me how to profile this HIP application with rocprof.

How to install hip-rocm

1Skills CLI (Vercel)

npx skills add mohitmishra786/low-level-dev-skills --skill hip-rocm -a claude-code

2Manually: put the files in place

~/.claude/skills/hip-rocm/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/hip-rocm/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about hip-rocm

How do I install hip-rocm in Claude Code?

Run npx skills add mohitmishra786/low-level-dev-skills --skill hip-rocm -a claude-code. The skill file is placed at ~/.claude/skills/hip-rocm/SKILL.md.

What does hip-rocm do?

It guides HIP development for AMD GPUs, including CUDA code conversion, application profiling, and device debugging.

Which ROCm tools does hip-rocm cover?

It includes hipcc for compilation, rocprof for profiling, and rocgdb for debugging. It also shows environment checks with rocminfo and rocm-smi.

Source text

SKILL.md · MIT
---
name: hip-rocm
description: HIP and ROCm skill for AMD GPU programming. Use when writing HIP kernels with hipcc, porting CUDA code via HIPIFY, profiling with rocprof, debugging with rocgdb, or optimizing for MI300X. Activates on queries about HIP, ROCm, hipify, hipcc, rocprof, or CUDA to AMD porting.
---

# HIP / ROCm

## Purpose

Guide agents through AMD GPU programming with HIP: the HIP runtime API, `hipcc` compilation, porting CUDA code with HIPIFY (`hipify-perl`, `hipify-clang`), ROCm toolchain setup, profiling with `rocprof`, debugging with `rocgdb`, HIP-vs-CUDA API mapping, and MI300X-specific optimizations.

## When to Use

- Porting an existing CUDA codebase to AMD GPUs
- Setting up ROCm on Linux for MI200/MI300 hardware
- Writing native HIP kernels for AMD data center GPUs
- Profiling HIP applications with rocprof or rocprofiler-sdk
- Debugging device faults with rocgdb or compute sanitizers
- Building multi-vendor GPU code with HIP portability macros

## Workflow

### 1. ROCm installation and verification

```bash
# Ubuntu/Debian (check ROCm docs for your distro version)
sudo apt install rocm-dev rocm-libs hip-dev

# Verify
rocminfo | head -30
hipconfig --version
hipcc --version

# List devices
rocm-smi
```

Set GPU target for compilation:

```bash
export AMDGPU_TARGETS=gfx942   # MI300X
export HIP_PLATFORM=amd
```

### 2. Minimal HIP kernel

```cpp
// vector_add.hip
#include <hip/hip_runtime.h>
#include <stdio.h>

__global__ void vector_add(const float *a, const float *b, float *c, int n) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i < n)
        c[i] = a[i] + b[i];
}

int main(void) {
    const int n = 1 << 20;
    size_t bytes = n * sizeof(float);
    float *d_a, *d_b, *d_c;

    hipMalloc(&d_a, bytes);
    hipMalloc(&d_b, bytes);
    hipMalloc(&d_c, bytes);

    int threads = 256;
    int blocks = (n + threads - 1) / threads;
    hipLaunchKernelGGL(vector_add, dim3(blocks), dim3(threads), 0, 0,
                       d_a, d_b, d_c, n);
    hipDeviceSynchronize();

    hipFree(d_a); hipFree(d_b); hipFree(d_c);
    return 0;
}
```

```bash
hipcc -O3 --offload-arch=gfx942 -o vector_add vector_add.hip
./vector_add
```

### 3. CUDA → HIP porting with HIPIFY

```bash
# Perl-based batch converter (quick port)
hipify-perl cuda_kernel.cu > cuda_kernel.hip

# Clang-based (more accurate, preserves structure)
hipify-clang cuda_project/ -o hip_project/ --cuda-path=/usr/local/cuda

# Convert single file in place
hipify-clang -inplace --cuda-path=/usr/local/cuda main.cu
```

Common API mappings:

| CUDA | HIP |
|------|-----|
| `cudaMalloc` | `hipMalloc` |
| `cudaMemcpy` | `hipMemcpy` |
| `cudaMemcpyAsync` | `hipMemcpyAsync` |
| `cudaStream_t` | `hipStream_t` |
| `<<<grid, block>>>` | `hipLaunchKernelGGL` or `<<<>>>` (HIP supports CUDA syntax) |
| `__syncthreads()` | `__syncthreads()` (same) |
| `threadIdx` / `blockIdx` | Same builtins |

Portability header for dual compilation:

```cpp
#ifdef __HIP_PLATFORM_AMD__
#include <hip/hip_runtime.h>
#else
#include <cuda_runtime.h>
#define hipMalloc cudaMalloc
#define hipMemcpy cudaMemcpy
// ... more macros
#endif
```

### 4. hipcc flags

```bash
# Target specific GPU architecture
hipcc --offload-arch=gfx942 -O3 -o app main.hip

# Multiple architectures
hipcc --offload-arch=gfx90a --offload-arch=gfx942 -o app main.hip

# Debug
hipcc -g -O0 --offload-arch=gfx942 -o app_debug main.hip

# Link with rocBLAS
hipcc -lrocblas -o app main.hip
```

### 5. rocprof profiling

```bash
# Basic kernel trace
rocprof --stats ./app

# CSV metrics output
rocprof -i input.csv -o output.csv ./app

# input.csv example:
# pmc: SQ_INSTS_VALU_ADD_F32,SQ_INSTS_VALU_MUL_F32,GRBM_COUNT
```

```bash
# ROCm 6.x rocprofiler-sdk (preferred for new projects)
rocprofv3 --kernel-trace -- ./app
```

Key metrics (AMD terminology):
- **VALU utilization** — compute unit activity
- **LDS bank conflicts** — shared memory (LDS) stalls
- **Memory throughput** — HBM bandwidth utilization

### 6. rocgdb debugging

```bash
# Build with debug symbols
hipcc -g -O0 --offload-arch=gfx942 -o app_debug main.hip

rocgdb ./app_debug
```

```gdb
(rocgdb) break vector_add
(rocgdb) run
(rocgdb) info rocm kernels
(rocgdb) rocm thread 0 0 0
(rocgdb) print i
```

AMD also supports `compute-sanitizer` equivalents via ROCm's `roc-obj-extract` and memory checking tools where available.

### 7. MI300X optimizations

```bash
# Enable MFMA (matrix fused multiply-add) instructions
hipcc --offload-arch=gfx942 -munsafe-fp-atomics -O3 -o app main.hip
```

| Optimization | MI300X note |
|--------------|-------------|
| Matrix ops | Use rocBLAS/hipBLASLt for GEMM; MFMA intrinsics for custom |
| HBM bandwidth | ~5.3 TB/s peak (MI300X) — maximize memory coalescing to approach it |
| Wavefront size | 64 threads (vs CUDA warp 32) — adjust reduction patterns |
| LDS (shared mem) | 64 KB per CU; watch bank conflicts |

Wavefront-aware reduction:

```cpp
__device__ float warp_reduce_sum(float val) {
    // AMD wavefront = 64 lanes
    for (int offset = 32; offset > 0; offset >>= 1)
        val += __shfl_down(val, offset);
    return val;
}
```

### 8. Library ecosystem

| NVIDIA | AMD ROCm |
|--------|----------|
| cuBLAS | rocBLAS / hipBLAS |
| cuDNN | MIOpen |
| NCCL | rccl |
| Thrust | hipCUB (portable) |
| cuFFT | rocFFT |

```bash
hipcc -lrocblas -o gemm_test gemm.hip
```

## Common Problems

| Symptom | Cause | Fix |
|---------|-------|-----|
| `hipErrorNoDevice` | ROCm driver not loaded | Check `rocm-smi`; add user to `render` group |
| Wrong architecture binary | Mismatched `gfx*` target | `rocminfo` → set `--offload-arch` |
| hipify incomplete port | CUDA-specific APIs | Manual fix: cooperative groups, texture refs |
| Slower than CUDA reference | Wavefront 64 vs warp 32 | Tune block size to multiples of 64 |
| `HSA_STATUS_ERROR` | GPU busy or OOM | `rocm-smi --showmeminfo`; reduce allocation |
| rocprof empty output | No kernels launched | Verify `hipGetLastError()` after launch |

## Related Skills

- `skills/gpu/cuda` — source CUDA patterns being ported
- `skills/gpu/cuda-profiling` — Nsight concepts map to rocprof
- `skills/gpu/gpu-memory-model` — wavefront vs warp, coalescing rules
- `skills/gpu/triton-lang` — Triton supports AMD via ROCm backend
- `skills/compilers/llvm` — HIP uses Clang/LLVM toolchain

© mohitmishra786 · MIT · mohitmishra786/low-level-dev-skills

Similar skills

All skills for AI and ML →

From the same set140

The whole set →
dpdk Skill for DPDK work: EAL init, poll-mode driver setup, mbuf pools, rte_ring, huge pages, RSS, and testpmd validation. CX Codex +1 369installs timers-pwm-baremetal timers-pwm-baremetal — a skill to configure MCU timers without an OS: PWM for LED dimming and motor control, input capture for pulse measurement, and periodic interrupts via SysTick. Works on STM32 and other bare-metal platforms. CX Codex +1 367installs mlir Skill for working with MLIR, a compiler infrastructure where each abstraction level lives in its own dialect. Useful when building domain-specific compilers and optimizers. CX Codex +1 366installs hypervisor-internals The hypervisor-internals skill explains Intel VT-x and AMD-V internals, from VMCS and VMCB to EPT/NPT and VMEXIT handling. Use it while studying or building a small hypervisor. CX Codex +1 365installs io-uring Skill for working with io_uring, the new asynchronous I/O interface in Linux. Use it when building high-performance servers and you need to reduce syscall overhead and enable zero-copy data transfer. CX Codex +1 361installs arm-sve arm-sve — a skill for Scalable Vector Extension programming on ARM servers. Teaches vector-length agnostic SIMD code that adapts to hardware vector width on Graviton, Apple M4, and other AArch64 platforms. CX Codex +1 361installs af-xdp Configures AF_XDP sockets and shared UMEM buffers for low-latency packet processing. Helps implement fast network filtering directly in userspace. CX Codex +1 359installs triton-lang triton-lang is a Claude Code skill that teaches agents to write Triton GPU kernels with @triton.jit, masked block operations, atomics, autotuning, and PyTorch integration. CX Codex +1 358installs

Project sponsors

Companies that keep this analytics open