vLLM en IBM POWER: inferencia de LLMs sin GPU
vLLM en IBM POWER: inferencia de LLMs sin GPU
El primer paquete vLLM precompilado para Linux ppc64le. No viene de IBM. No viene de Canonical. Lo ha construido la comunidad — y corre en el hardware que ya tienes.
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 ppc64leEjecutar Ubuntu en IBM POWER es la base de este flujo de trabajo. SIXE despliega y soporta entornos Ubuntu ppc64le como Canonical Partner — la misma infraestructura que hace posible esta instalación por APT. Si tu equipo necesita profundizar en la administración de Linux en Power, tenemos formación oficial IBM específica para ello.
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 construidoEl 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/linuxLuego 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 8000curl 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/s12 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| Sistema | Hilos | tok/s | Eficiencia por core |
|---|---|---|---|
| POWER10 | 1 | 13,9 | 13,9 tok/s/core |
| POWER9 | 12 | 17,6 | 1,5 tok/s/core |
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:
↓
vLLM la recibe y la divide en tokens
↓
PyTorch ejecuta las matemáticas de la red neuronal
↓
Para cada capa: multiplica matrices grandes (GEMM)
↓
PyTorch le pide a OpenBLAS: “multiplica estas dos matrices BF16”
↓
OpenBLAS ejecuta sbgemm_kernel_power10 ← AQUÍ SE USA MMA
↓
El hardware POWER10 ejecuta instrucciones MMA
↓
El resultado sube, se elige el siguiente token
↓
Ves aparecer la siguiente palabra
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
| Tecnología | Qué es | ¿Activa en nuestra build? |
|---|---|---|
| POWER10 MMA (BF16) | Acelerador matricial integrado en la CPU | Sí — PyTorch → OpenBLAS |
| POWER10 MMA (int8) | El mismo hardware, para modelos de 8 bits | Compilado, no end-to-end aún |
| IBM Spyre | Tarjeta aceleradora de IA separada | No — hardware diferente |
| OpenShift AI | Plataforma ML completa en Kubernetes | No — somos la alternativa ligera |
| oneDNN | Librería matemática incluida en vLLM | Compilada, PyTorch la saltea |
| OpenBLAS | Librería matemática con kernels POWER10 a mano | Sí — el verdadero motor |
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.
| OpenShift AI | LibrePower vLLM | |
|---|---|---|
| Instalación | Clúster OpenShift + operadores | apt install python3-vllm |
| Infraestructura | Kubernetes obligatorio | Cualquier Ubuntu/Debian ppc64le |
| Alcance | Ciclo ML completo | Solo inferencia |
| Soporte | Suscripción Red Hat | Comunidad (código abierto) |
| GPU | Soportada (x86) | Solo CPU (nativo POWER) |
| Tiempo hasta la primera inferencia | Horas o días | Minutos |
| Coste | Licenciamiento OpenShift | Gratuito |
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.shEl 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.
SIXE ayuda a las organizaciones a desplegar y operar Linux en IBM POWER — desde formación oficial hasta soporte de infraestructura completo. Si estás evaluando inferencia de LLMs en hardware POWER existente o quieres saber cómo encaja con tu arquitectura actual, hablemos. También puedes leer más sobre el contexto más amplio de IA open source en IBM Power en nuestro artículo sobre cómo montar una factoría de IA con stack open source.
Prueba vLLM en IBM POWER
Si tienes un sistema con Ubuntu, son tres comandos. El código fuente está en GitLab si quieres profundizar o contribuir.
# Añadir el repositorio LibrePower
curl -fsSL https://linux.librepower.org/install.sh | sudo sh
# Instalar vLLM para ppc64le
sudo apt update && sudo apt install python3-vllm
# Instalar PyTorch (wheels de IBM)
pip3 install torch --extra-index-url \
https://wheels.developerfirst.ibm.com/ppc64le/linux
# 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
Ver Repositorio en GitLab
