Compilación de llama.cpp con HIP para GPUs AMD (ROCm)

Introducción

Este artículo documenta el proceso de compilación de llama.cpp con backend HIP para utilizar aceleración por GPU en hardware AMD, dentro del stack de inferencia local de modelos LLM. La integración se realiza sobre ROCm, interactuando directamente con la GPU mediante HIP y, opcionalmente, rocWMMA para optimizar Flash Attention en arquitecturas modernas.

El caso documentado corresponde a un sistema Fedora 43, con Ryzen 9 5900X y una GPU RDNA3 (gfx1100). El enfoque es extrapolable a otras GPUs AMD compatibles, pero las decisiones y validaciones están hechas específicamente sobre este entorno.

Enfoque general / Arquitectura

El flujo seguido es intencionadamente directo:

• llama.cpp se compila desde código fuente.
• Se habilita el backend GGML_HIP mediante CMake.
• La compilación se ajusta explícitamente a la arquitectura de la GPU (GPU_TARGETS).
• El binario resultante (llama-cli o llama-server) ejecuta inferencia usando GPU vía HIP.

No se emplean contenedores ni capas intermedias. Se prioriza control total del toolchain, visibilidad de errores y reproducibilidad en el sistema base Fedora.

Requisitos previos

• Fedora 43.
• GPU AMD compatible con ROCm / HIP (RDNA2+, RDNA3 o CDNA).
• ROCm instalado y operativo.
• clang proporcionado por ROCm accesible vía hipconfig.
• CMake moderno.
• Espacio suficiente para la compilación.

Desarrollo

Clonado del repositorio

Se parte siempre del repositorio oficial de llama.cpp, evitando forks o parches externos que puedan introducir comportamientos no controlados.

Compilación con HIP habilitado

La compilación se realiza indicando explícitamente:

• El compilador HIP (HIPCXX).
• La ruta base de ROCm (HIP_PATH).
• Activación del backend HIP en GGML.
• Arquitectura concreta de la GPU (gfx1100).
• Build en modo Release.
• Paralelización elevada, acorde al Ryzen 9 5900X.

HIPCXX="$(hipconfig -l)/clang" HIP_PATH="$(hipconfig -R)" \
cmake -S . -B build \
  -DGGML_HIP=ON \
  -DGGML_HIP_ROCWMMA_FATTN=ON \
  -DGPU_TARGETS=gfx1100 \
  -DCMAKE_BUILD_TYPE=Release \
&& cmake --build build --config Release -- -j 24

Decisiones técnicas relevantes

• GPU_TARGETS=gfx1100 Se fuerza la arquitectura RDNA3 para evitar builds genéricos innecesarios y reducir tanto tiempos de compilación como tamaño del binario.

• GGML_HIP_ROCWMMA_FATTN=ON Activa Flash Attention optimizado mediante rocWMMA, especialmente relevante en RDNA3.

• No se omite GPU_TARGETS: aunque es opcional, dejarlo implícito suele derivar en builds más lentas y menos predecibles.

Uso del binario resultante

Tras la compilación, los binarios quedan disponibles en:

build/bin/

La ayuda completa puede consultarse con:

./build/bin/llama-cli -h

Ejemplo mínimo de ejecución con llama-cli:

./build/bin/llama-cli \
  -m /ruta/a/tu/modelo.gguf \
  -p "Building a website can be done in 10 steps:"

La ruta del modelo depende del layout local de almacenamiento y no forma parte de esta documentación.

Ejecución como servicio con llama-server

Además del modo CLI, llama.cpp incluye llama-server, pensado para ejecutar inferencia persistente mediante una API HTTP (compatible con clientes tipo OpenAI).

Este modo es el habitual cuando se quiere:

• Mantener el modelo cargado en GPU.
• Evitar tiempos de arranque por inferencia.
• Consumir el modelo desde aplicaciones externas.

Ejemplo básico y genérico, válido para pruebas iniciales en GPU AMD con HIP:

./build/bin/llama-server \
  -m /ruta/a/tu/modelo.gguf \
  -ngl 99 \
  -c 4096 \
  --host 127.0.0.1 \
  --port 5000

Notas sobre los parámetros usados:

• -m Modelo GGUF a cargar.

• -ngl 99 Intenta offloadear el mayor número posible de capas a la GPU. En sistemas con VRAM suficiente, equivale a "todo a GPU".

• -c 4096 Tamaño de contexto moderado para uso general. Valores altos incrementan consumo de VRAM.

• --host / --port Dirección y puerto de escucha del servidor.

Este ejemplo evita opciones avanzadas (quantización de KV, Flash Attention explícito, buffers personalizados, plantillas de chat, etc.) para mantener un baseline claro y portable.

Aceleración adicional con rocWMMA

En arquitecturas RDNA3+ o CDNA, rocWMMA permite acelerar de forma significativa las operaciones de Flash Attention.

• Se incluye por defecto al instalar ROCm mediante el meta-paquete rocm.
• Alternativamente puede instalarse mediante paquetes rocwmma-dev / rocwmma-devel, según la distribución.

En escenarios no estándar, es posible añadir manualmente el include path:

-DCMAKE_CXX_FLAGS="-I<ruta>/rocwmma/library/include/"

Problemas detectados y resolución

Error: ROCm device library no encontrada

Error típico durante la compilación:

clang: error: cannot find ROCm device library;

Resolución aplicada:

1. Localizar dentro de HIP_PATH un directorio que contenga el archivo:

   oclc_abi_version_400.bc
   

2. Definir la variable HIP_DEVICE_LIB_PATH apuntando a dicho directorio:

HIPCXX="$(hipconfig -l)/clang" HIP_PATH="$(hipconfig -p)" \
HIP_DEVICE_LIB_PATH=<directorio_encontrado> \
cmake -S . -B build \
  -DGGML_HIP=ON \
  -DGPU_TARGETS=gfx1030 \
  -DCMAKE_BUILD_TYPE=Release \
&& cmake --build build -- -j 16

Arquitecturas GPU y detección

La arquitectura activa puede identificarse con:

rocminfo | grep gfx | head -1

Ejemplos habituales:

• gfx1030 → RDNA2
• gfx1100 → RDNA3 (RX 7900 XTX / XT / GRE)

Si la GPU no está oficialmente soportada:

• HSA_OVERRIDE_GFX_VERSION=10.3.0 para RDNA2.
• HSA_OVERRIDE_GFX_VERSION=11.0.0 para RDNA3.

Variables de entorno relevantes

• HIP_VISIBLE_DEVICES Limita qué GPU(s) son visibles para HIP.

• HSA_OVERRIDE_GFX_VERSION Fuerza compatibilidad con arquitecturas similares cuando el soporte no es oficial.

Resumen breve

• llama.cpp puede compilarse con HIP para GPUs AMD usando ROCm en Fedora 43.
• Forzar GPU_TARGETS mejora tiempos, tamaño y control del binario.
• rocWMMA aporta mejoras reales en Flash Attention sobre RDNA3.
• La compilación directa ofrece mayor control que soluciones encapsuladas.

Notas personales

HIP no es inmediato ni indulgente, pero una vez alineado el toolchain en Fedora, el resultado es estable y consistente. Para inferencia local seria en hardware AMD, ROCm sigue siendo el camino más realista pese a sus fricciones.

Referencias

• llama.cpp – Build documentation
• Repositorio oficial de llama.cpp