vLLM en IBM POWER: inferencia de LLMs sin GPU

El paquete: qué y como

Qué hemos construido: vLLM en IBM POWER como paquete .deb

vLLM es el motor de inferencia de LLMs de código abierto más usado. Impulsa inferencia a escala de millones de peticiones diarias en producción. Soporta la API OpenAI completa: /v1/chat/completions, /v1/completions, /v1/models — streaming, llamadas a funciones, uso de herramientas.

El problema era que no existían paquetes precompilados para ppc64le. Ni en PyPI. Ni en los repositorios de Ubuntu. Ni de IBM. Si querías vLLM en IBM POWER, tenías que apañártelas. La propia comunidad de IBM tiene documentado lo complejo que es el proceso manual.

Así que lo compilamos nosotros. En hardware IBM POWER real. Optimizado para la arquitectura. Y lo empaquetamos como un .deb que APT puede instalar con resolución completa de dependencias.

$ apt-cache show python3-vllm

Package: python3-vllm
Version: 0.9.2-1
Architecture: ppc64el
Maintainer: LibrePower <packages@librepower.org>
Depends: python3 (>= 3.10), python3-numpy, python3-requests
Homepage: https://librepower.org/stack/databases-operating-systems/linux/
Description: Servidor de inferencia LLM compatible con OpenAI para ppc64le

El código

El proceso: de código fuente a paquete .deb en ppc64le

Compilar vLLM para POWER no es un simple pip install. Aquí está lo que implicó.

PyTorch en POWER

vLLM depende de PyTorch, que no se distribuye para ppc64le en PyPI. IBM publica wheels en wheels.developerfirst.ibm.com — las usamos como base. Puedes consultar el catálogo completo de herramientas de desarrollo soportadas por IBM para POWER.

La extensión C++

La ruta de alto rendimiento de vLLM es una extensión C++ (_C.abi3.so) que gestiona la atención, el caché, las funciones de activación y la cuantización. Hay que compilarla desde el código fuente con CMake, enlazando contra la API C++ de PyTorch y oneDNN para operaciones GEMM optimizadas.

-- PowerPC detectado
-- Flags de compilación: -fopenmp -DVLLM_CPU_EXTENSION
   -mvsx -mcpu=power9 -mtune=power9
-- Archivos fuente: csrc/cpu/quant.cpp csrc/cpu/activation.cpp
   csrc/cpu/attention.cpp csrc/cpu/cache.cpp csrc/cpu/utils.cpp
   csrc/cpu/layernorm.cpp csrc/cpu/pos_encoding.cpp
[100%] Enlazando módulo compartido _C.abi3.so
[100%] Objetivo _C construido

El binario resultante incluye oneDNN con kernels GEMM para PPC64 — la misma librería matemática que Intel usa para x86, pero apuntando a las unidades vectoriales de POWER.

Resolución de dependencias

El ecosistema Python en ppc64le tiene lagunas. Algunos paquetes tienen wheels precompiladas; otros necesitan compilación desde el código fuente; y unos pocos tienen conflictos de versión. Resolvimos todo esto para que tú no tengas que hacerlo.

En la práctica

Inferencia de LLMs en IBM POWER: código y resultado

Así es como se ve en la práctica. Primero, instala el paquete:

# Añadir el repositorio APT de LibrePower
curl -fsSL https://linux.librepower.org/install.sh | sudo sh

# Instalar vLLM para ppc64le
sudo apt update
sudo apt install python3-vllm

# Instalar wheels de PyTorch desde IBM
pip3 install torch --extra-index-url \
  https://wheels.developerfirst.ibm.com/ppc64le/linux

Luego ejecuta inferencia desde Python:

# Python
from vllm import LLM, SamplingParams

llm = LLM(
    model="Qwen/Qwen2.5-0.5B-Instruct",
    dtype="bfloat16",
    device="cpu",
    enforce_eager=True
)

output = llm.generate(
    ["Explica la computación cuántica en términos sencillos."],
    SamplingParams(temperature=0, max_tokens=100)
)

print(output[0].outputs[0].text)

Pero el valor real de vLLM no está en un script Python — está en el modo servidor, compatible con la API de OpenAI:

# Arrancar el servidor de inferencia compatible con OpenAI
python3 -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-0.5B-Instruct \
    --device cpu --dtype bfloat16 --port 8000

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Qwen/Qwen2.5-0.5B-Instruct",
    "messages": [{"role": "user", "content": "¿Qué es IBM POWER?"}],
    "max_tokens": 100
  }'

LangChain, LlamaIndex, Open WebUI, Continue.dev — cualquier aplicación que pueda apuntar a un endpoint OpenAI funciona sin modificaciones. Cambias base_url a tu servidor POWER y listo. Esto es lo que convierte la inferencia en CPU sobre IBM POWER en una ruta real hacia el despliegue de IA generativa en infraestructura propia, sin dependencia de GPU ni de nube pública.

Los números

Rendimiento real en POWER9 y POWER10: benchmarks de inferencia

Hicimos benchmarks en ambas generaciones con Qwen2.5-0.5B-Instruct (494M parámetros, BF16). No son numeritos imaginarios :p vienen de ejecutar la herramienta de benchmark en hardware real.

POWER9

$ OMP_NUM_THREADS=12 python3 bench_vllm.py
Ejecución 1: 17,8 tok/s (100 tokens en 5,6 s)
Ejecución 2: 16,7 tok/s (100 tokens en 6,0 s)
Ejecución 3: 18,5 tok/s (100 tokens en 5,4 s)
Benchmark POWER9: hilos=12 media=17,6 tok/s

12 hilos es el punto óptimo — más hilos añaden contención de caché en esta carga de trabajo limitada por ancho de banda de memoria.

POWER10

$ OMP_NUM_THREADS=1 python3 bench_vllm.py
Ejecución 1: 13,9 tok/s (100 tokens en 7,2 s)
Benchmark POWER10: hilos=1 media=13,9 tok/s

Esto no compite con una A100 — cubre un hueco completamente diferente: ejecutar inferencia de modelos de lenguaje en la infraestructura IBM POWER que ya tienes. Sin presupuesto para GPU, sin slots PCIe, sin dolores de cabeza con drivers. Para organizaciones con servidores POWER9 o POWER10 existentes, este es el camino sin inversión en capital adicional hacia la IA privada.

También probamos Qwen2.5-7B-Instruct (7.000 millones de parámetros) en un único core POWER10 — cargó y corrió a 1,0 tok/s. No es suficiente para uso interactivo en un solo core, pero demuestra que los modelos más grandes funcionan. Con más cores, esto escala linealmente. En SIXE recibimos habitualmente esta pregunta de clientes con sistemas IBM POWER en producción: ¿puedo usar este hardware para IA? La respuesta ya es sí.

Dentro de la máquina

Qué ocurre realmente cuando POWER10 ejecuta un modelo de lenguaje

Si has visto las presentaciones de IBM sobre IA en POWER, probablemente te hayas encontrado con términos como MMA, Spyre, oneDNN y OpenShift AI. Suelen aparecer juntos en la misma diapositiva. ¿Qué significan realmente? ¿Y cuáles están activos cuando ejecutas python3 -m vllm?

Fuimos al fondo del stack de software para responder a esto. Los resultados nos sorprendieron.

Glosario rápido sin jerga innecesaria

• LLM (modelo de lenguaje grande) — Software que genera texto: ChatGPT, Llama, Qwen. Un modelo matemático con miles de millones de números que predice la siguiente palabra.
• Inferencia — Ejecutar un modelo ya entrenado para obtener respuestas. El entrenamiento enseña al modelo; la inferencia lo usa. Este artículo habla solo de inferencia.
• Token — Una palabra o parte de una palabra. “17,6 tokens por segundo” significa roughly 17-18 palabras por segundo.
• BF16 (bfloat16) — Una forma de almacenar números usando 16 bits en lugar de 32. La mitad de memoria, casi la misma precisión. Piénsalo como: “calidad suficiente a la mitad del coste de almacenamiento”.
• GEMM (multiplicación de matrices general) — La operación matemática central de las redes neuronales. La mayor parte del tiempo de cómputo en inferencia LLM se invierte en multiplicar matrices grandes.
• MMA (Matrix-Multiply Accumulate) — Circuitería dedicada dentro de POWER10 diseñada para acelerar las matemáticas matriciales. Como una calculadora especializada para la operación específica que domina la inferencia LLM.
• OpenBLAS — Una librería matemática de código abierto con GEMM optimizada. El motor que hace la multiplicación de matrices real en POWER.
• oneDNN — La librería matemática de Intel, también compilada en vLLM. Otro motor para el mismo propósito.
• PyTorch — El framework que ejecuta la red neuronal. Llama a OpenBLAS o oneDNN para las matemáticas pesadas.

Cómo encajan las piezas

Cuando vLLM genera un token, este es el camino exacto a través de la máquina:

La prueba: BF16 frente a FP32 en POWER10

En POWER10, MMA acelera las matemáticas BF16. En POWER9 (sin MMA), BF16 es en realidad más lento que FP32 por emulación software. Si MMA funciona, BF16 debe ser más rápido:

# Benchmark de multiplicación de matrices (1024×1024) en POWER10
BF16: 384,4 GFLOPS  (5,6 ms)
FP32: 249,6 GFLOPS  (8,6 ms)
Ratio BF16/FP32: 1,54×

BF16 es 1,54× más rápido que FP32. MMA está activo y entrega aceleración medible. Nuestros 13,9 tok/s en un único core POWER10 ya incluyen MMA. Ese es el número real, acelerado por hardware. Las capacidades de aceleración de IA de POWER10 son algo que tratamos en profundidad en nuestros servicios de soporte y mantenimiento de IBM POWER.

La investigación sobre oneDNN (y lo que aprendimos)

Inicialmente pensamos que podría haber rendimiento extra sin aprovechar.

La build de vLLM incluye oneDNN (originalmente de Intel). Dentro hay dos rutas matemáticas específicas para POWER:

• GEMM int8: Un kernel escrito a mano por ingenieros de IBM con instrucciones MMA para modelos cuantizados.
• GEMM BF16: Un paso directo a OpenBLAS — pero solo cuando se compila con flags específicos.

Nuestra build inicial no tenía esos flags. Recompilamos con -DDNNL_BLAS_VENDOR=OPENBLAS, confirmamos que los flags estaban activos, volvimos a hacer el benchmark — mismo rendimiento.

¿Por qué? PyTorch ya iba directamente a OpenBLAS, saltándose oneDNN para las operaciones matriciales principales. La optimización ya estaba ahí; simplemente no lo sabíamos.

¿Y qué hay de IBM Spyre?

IBM Spyre es una tarjeta aceleradora de IA dedicada para POWER — hardware completamente separado con su propio silicio para matemáticas de IA. La distinción clave:

• MMA = aceleración integrada dentro de cada core POWER10 (activa ahora mismo en nuestros benchmarks)
• Spyre = tarjeta aceleradora de IA separada que se añade al sistema (prometedora, pero requiere stacks de software específicos de IBM)

Nuestro trabajo se centra en lo que está disponible hoy usando la CPU que ya tienes en tu máquina, sin inversión adicional en hardware.

El cuadro completo

Contexto

El panorama: inferencia de LLMs en IBM POWER sin OpenShift

Red Hat OpenShift AI

Hasta ahora, la propuesta oficial de IBM/Red Hat para inferencia de LLMs en IBM POWER era OpenShift AI. Soporta notebooks, pipelines, entrenamiento de modelos, serving y monitorización. Desde la versión 3.0, corre en ppc64le con cargas de trabajo solo de CPU.

OpenShift AI es la elección correcta para organizaciones que ya tienen clústeres OpenShift. Viene con RBAC, InstructLab para fine-tuning de modelos y soporte enterprise.

Pero requiere OpenShift. Un clúster Kubernetes, una suscripción Red Hat, gestión de operadores. Para muchos entornos POWER — especialmente los que corren Linux standalone o entornos mixtos AIX/Linux — eso es un compromiso significativo solo para servir un modelo. Estas son exactamente las organizaciones que gestionan su infraestructura IBM POWER con soporte de SIXE.

En SIXE llevamos años ayudando a clientes con IBM POWER a modernizar sus cargas de trabajo. La aparición de inferencia de IA local sobre ppc64le encaja directamente con la línea editorial que describimos en nuestro artículo sobre factoría de IA con stack open source: IA en producción, sin dependencia de nube pública, sobre infraestructura que ya pagas.

Lo que aporta LibrePower

No estamos reemplazando OpenShift AI. Lo complementamos con una ruta más ligera para los muchos entornos POWER que no necesitan la plataforma completa.

IBM construye la autopista — hardware de primer nivel, wheels de PyTorch, OpenShift AI, InstructLab. LibrePower añade un acceso directo para quienes no necesitan la plataforma completa. El roadmap de IA en IBM POWER avanza rápido, y las herramientas de comunidad como esta cubren huecos reales en el ecosistema actual.

La infraestructura

Cómo funciona el repositorio de paquetes de LibrePower

Construimos librepower.org siguiendo el mismo patrón que nuestro repositorio de paquetes AIX — infraestructura que ya sirve más de 30 paquetes de código abierto a sistemas AIX en todo el mundo.

linux.librepower.org/
  dists/jammy/
    InRelease          (firmado con GPG)
    Release
    main/binary-ppc64el/
      Packages
  pool/main/
    python3-vllm_0.9.2-1_ppc64el.deb
  install.sh

El CI/CD corre en GitLab: cada push regenera los metadatos APT y despliega automáticamente. Todos los paquetes compilados en hardware IBM POWER real — no compilación cruzada, no emulación. El código fuente completo está en GitLab bajo Apache 2.0.

Hoja de ruta

Qué viene después para vLLM en IBM POWER

• Más modelos probados — Llama, Mistral, Phi, Granite. Benchmarks sistemáticos por familia de modelos.
• llama.cpp para ppc64le — Modelos GGUF cuantizados para una huella de memoria aún menor. Ya disponible para AIX.
• Soporte para Ubuntu 24.04 y Debian 12 — Extendiendo el paquete a las últimas versiones LTS.
• Variantes optimizadas para POWER10 — Profundizando en el tuning de MMA. Nuestros 13,9 tok/s por core son un punto de partida, no un techo.
• GEMM int8 end-to-end — Completando la ruta MMA para modelos cuantizados, lo que debería mejorar el throughput.