vLLM sur IBM POWER : inférence LLM sans GPU

Le paquet

Ce que nous avons construit : vLLM sur IBM POWER en paquet .deb

vLLM est le moteur d’inférence LLM open source le plus utilisé. Il alimente l’inférence à l’échelle de millions de requêtes quotidiennes en production. Il prend en charge l’API OpenAI complète : /v1/chat/completions, /v1/completions, /v1/models — streaming, appels de fonctions, usage d’outils.

Le problème : il n’existait aucun paquet précompilé pour ppc64le. Ni sur PyPI. Ni dans les dépôts Ubuntu. Si vous vouliez vLLM sur IBM POWER, vous étiez livré à vous-même. La communauté IBM elle-même a documenté la complexité de l’installation manuelle.

Nous l’avons donc compilé. Sur du vrai matériel IBM POWER. Optimisé pour l’architecture. Et packagé sous forme de .deb qu’APT peut installer avec résolution complète des dépendances.

$ 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: Serveur d'inférence LLM compatible OpenAI pour ppc64le

Sous le capot

Le processus : du code source au paquet .deb sur ppc64le

Compiler vLLM pour POWER n’est pas un simple pip install. Voici ce que cela a impliqué.

PyTorch sur POWER

vLLM dépend de PyTorch, qui n’est pas distribué pour ppc64le sur PyPI. IBM publie des wheels sur wheels.developerfirst.ibm.com — nous les utilisons comme base. Consultez le catalogue complet des outils de développement IBM supportés pour POWER.

L’extension C++

La voie haute performance de vLLM est une extension C++ (_C.abi3.so) qui gère l’attention, le cache, les fonctions d’activation et la quantification. Elle doit être compilée depuis le code source avec CMake, en liant l’API C++ de PyTorch et oneDNN pour des opérations GEMM optimisées.

-- PowerPC détecté
-- Flags de compilation : -fopenmp -DVLLM_CPU_EXTENSION
   -mvsx -mcpu=power9 -mtune=power9
-- Fichiers source : 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%] Liaison du module partagé CXX _C.abi3.so
[100%] Cible _C construite

Le binaire résultant inclut oneDNN avec des noyaux GEMM PPC64 — la même bibliothèque mathématique qu’Intel utilise pour x86, mais ciblant les unités vectorielles de POWER.

Résolution des dépendances

L’écosystème Python sur ppc64le présente des lacunes. Certains paquets ont des wheels précompilées, d’autres nécessitent une compilation depuis le source, et quelques-uns ont des conflits de version. Nous avons tout résolu pour que vous n’ayez pas à le faire.

En pratique

Inférence LLM sur IBM POWER : code et résultat

Voici ce que cela donne en pratique. D’abord, installez le paquet :

# Ajouter le dépôt APT LibrePower
curl -fsSL https://linux.librepower.org/install.sh | sudo sh

# Installer vLLM pour ppc64le
sudo apt update
sudo apt install python3-vllm

# Installer les wheels PyTorch d'IBM
pip3 install torch --extra-index-url \
  https://wheels.developerfirst.ibm.com/ppc64le/linux

Puis exécutez l’inférence depuis 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(
    ["Explique l'informatique quantique en termes simples."],
    SamplingParams(temperature=0, max_tokens=100)
)

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

Mais la vraie valeur de vLLM est le mode serveur, compatible avec l’API OpenAI :

# Démarrer le serveur d'inférence compatible 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'\''est-ce qu'\''IBM POWER ?"}],
    "max_tokens": 100
  }'

LangChain, LlamaIndex, Open WebUI, Continue.dev — toute application pouvant pointer vers un endpoint OpenAI fonctionne sans modification. Changez base_url vers votre serveur POWER et c’est tout. C’est ce qui fait de l’inférence CPU sur IBM POWER une voie réaliste vers le déploiement d’IA générative sur infrastructure propre, sans dépendance GPU ni cloud public.

Les chiffres

Performances réelles sur POWER9, POWER10 et POWER11 : benchmarks d’inférence

Nous avons effectué des benchmarks sur les deux générations POWER avec Qwen2.5-0.5B-Instruct (494M paramètres, BF16). Ce ne sont pas des chiffres théoriques — ils proviennent de l’exécution de l’outil de benchmark sur du vrai matériel.

POWER9

$ OMP_NUM_THREADS=12 python3 bench_vllm.py
Exécution 1 : 17,8 tok/s (100 tokens en 5,6 s)
Exécution 2 : 16,7 tok/s (100 tokens en 6,0 s)
Exécution 3 : 18,5 tok/s (100 tokens en 5,4 s)
Benchmark POWER9 : fils=12 moyenne=17,6 tok/s

12 fils est le point optimal — davantage de fils ajoutent de la contention de cache sur cette charge de travail limitée par la bande passante mémoire.

POWER10

$ OMP_NUM_THREADS=1 python3 bench_vllm.py
Exécution 1 : 13,9 tok/s (100 tokens en 7,2 s)
Benchmark POWER10 : fils=1 moyenne=13,9 tok/s

Ce n’est pas une concurrence avec une A100 — cela comble un fossé entièrement différent : exécuter l’inférence de LLMs sur l’infrastructure IBM POWER que vous possédez déjà. Sans budget GPU, sans slot PCIe, sans maux de tête liés aux drivers. Pour les organisations avec des serveurs POWER9, POWER10 ou POWER11 existants, c’est la voie vers l’IA privée sans investissement en capital supplémentaire.

Nous avons également testé Qwen2.5-7B-Instruct (7 milliards de paramètres) sur un seul cœur POWER10 — il a chargé et tourné à 1,0 tok/s. Insuffisant pour une utilisation interactive sur un cœur, mais preuve que les modèles plus grands fonctionnent. Avec davantage de cœurs, cela évolue linéairement. Nos clients disposant de systèmes IBM POWER en production nous posent régulièrement la question : puis-je utiliser ce matériel pour de l’IA ? La réponse est désormais oui.

À noter que les nouveaux serveurs IBM Power11 introduisent la carte accélératrice Spyre — un matériel dédié à l’IA qui viendra compléter cette approche CPU dans les prochains mois.

Dans la machine

Ce qui se passe vraiment quand POWER10/11 exécute un modèle de langage

Si vous avez vu les présentations IBM sur l’IA en POWER, vous avez probablement rencontré les termes MMA, Spyre, oneDNN et OpenShift AI. Ils apparaissent souvent sur la même diapositive. Que signifient-ils réellement ? Et lesquels sont actifs quand vous exécutez python3 -m vllm ?

Nous avons plongé dans la pile logicielle pour répondre à cette question. Les résultats nous ont surpris.

Lexique rapide sans jargon superflu

• LLM (grand modèle de langage) — Logiciel qui génère du texte : ChatGPT, Llama, Qwen. Un modèle mathématique avec des milliards de nombres qui prédit le mot suivant.
• Inférence — Exécuter un modèle déjà entraîné pour obtenir des réponses. L’entraînement apprend au modèle ; l’inférence l’utilise. Cet article parle uniquement d’inférence.
• Token — Un mot ou un fragment de mot. « 17,6 tokens par seconde » correspond à environ 17-18 mots par seconde.
• BF16 (bfloat16) — Une façon de stocker des nombres sur 16 bits au lieu de 32. Moitié moins de mémoire, précision quasi identique. En résumé : « qualité suffisante à la moitié du coût de stockage ».
• GEMM (multiplication générale de matrices) — L’opération mathématique centrale des réseaux de neurones. La majeure partie du temps de calcul en inférence LLM est consacrée à la multiplication de grandes matrices.
• MMA (Matrix-Multiply Accumulate) — Circuits dédiés à l’intérieur de POWER10 et POWER11 conçus pour accélérer les calculs matriciels. Comme une calculatrice spécialisée pour l’opération précise qui domine l’inférence LLM.
• OpenBLAS — Une bibliothèque mathématique open source avec des routines GEMM optimisées. Le moteur qui effectue la vraie multiplication de matrices sur POWER.
• oneDNN — La bibliothèque mathématique d’Intel, également compilée dans vLLM. Un autre moteur pour le même usage.
• PyTorch — Le framework qui exécute le réseau de neurones. Il appelle OpenBLAS ou oneDNN pour les calculs intensifs.

Comment les pièces s’assemblent

Quand vLLM génère un token, voici le chemin exact à travers la machine :

La preuve : BF16 vs FP32 sur POWER10/11

Sur POWER10 et POWER11, MMA accélère les calculs BF16. Sur POWER9 (sans MMA), BF16 est en réalité plus lent que FP32 à cause de l’émulation logicielle. Si MMA fonctionne, BF16 devrait être plus rapide :

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

BF16 est 1,54× plus rapide que FP32. MMA est actif et fournit une accélération mesurable. Nos 13,9 tok/s sur un seul cœur POWER10 incluent déjà MMA. C’est le chiffre réel, accéléré par le matériel. Les capacités d’accélération IA de POWER10 et POWER11 sont au cœur de nos formations Linux sur IBM POWER Systems disponibles en français.

L’investigation oneDNN (et ce que nous avons appris)

Nous pensions initialement qu’il restait des performances inexploitées.

La build vLLM intègre oneDNN (initialement d’Intel). À l’intérieur, il existe deux chemins mathématiques spécifiques à POWER :

• GEMM int8 : Un noyau écrit à la main par des ingénieurs IBM utilisant les instructions MMA pour les modèles quantifiés.
• GEMM BF16 : Un passage direct à OpenBLAS — mais seulement quand compilé avec des flags spécifiques.

Notre build initiale n’avait pas ces flags. Nous avons recompilé avec -DDNNL_BLAS_VENDOR=OPENBLAS, confirmé que les flags étaient actifs, re-benchmarké — mêmes performances.

Pourquoi ? PyTorch allait déjà directement à OpenBLAS, contournant oneDNN pour les opérations matriciales principales. L’optimisation était déjà là ; nous ne le savions simplement pas.

Et IBM Spyre ?

IBM Spyre est une carte accélératrice IA dédiée pour POWER — un matériel entièrement séparé avec son propre silicium pour les calculs IA. La distinction clé :

• MMA = accélération intégrée dans chaque cœur POWER10 et POWER11 (active dès maintenant dans nos benchmarks)
• Spyre = carte accélératrice IA séparée ajoutée au système (prometteuse, mais nécessite des piles logicielles IBM spécifiques)

Notre travail se concentre sur ce qui est disponible aujourd’hui en utilisant le CPU déjà dans votre machine, sans investissement matériel supplémentaire.

Le tableau complet

Contexte

Vue d’ensemble : inférence LLM sur IBM POWER sans OpenShift

Red Hat OpenShift AI

Jusqu’ici, la proposition officielle d’IBM/Red Hat pour l’inférence LLM sur IBM POWER était OpenShift AI. Il supporte les notebooks, pipelines, entraînement de modèles, serving et monitoring. Depuis la version 3.0, il tourne sur ppc64le avec des charges de travail CPU uniquement.

OpenShift AI est le bon choix pour les organisations qui ont déjà des clusters OpenShift. Il vient avec RBAC, InstructLab pour le fine-tuning de modèles et un support enterprise.

Mais il requiert OpenShift. Un cluster Kubernetes, un abonnement Red Hat, la gestion des opérateurs. Pour beaucoup d’environnements POWER — notamment ceux qui tournent sous Linux standalone ou des environnements mixtes AIX/Linux — c’est un engagement significatif juste pour servir un modèle. Ces organisations font justement appel au service de maintenance et support IBM POWER de SIXE pour maintenir leur infrastructure opérationnelle.

Ce qu’apporte LibrePower

Nous ne remplaçons pas OpenShift AI. Nous le complétons avec un chemin plus léger pour les nombreux environnements POWER qui n’ont pas besoin de la plateforme complète.

IBM construit l’autoroute — matériel de premier plan, wheels PyTorch, OpenShift AI, InstructLab. LibrePower ajoute une bretelle d’accès pour ceux qui n’ont pas besoin de la plateforme complète. La feuille de route IA d’IBM POWER avance rapidement, et les outils communautaires comme celui-ci comblent des lacunes réelles dans l’écosystème actuel. Pour une vue d’ensemble de l’évolution de POWER avec Power10 et Power11, consultez notre article sur les nouveaux serveurs IBM Power10.

L’infrastructure

Fonctionnement du dépôt de paquets LibrePower

Nous avons construit librepower.org en suivant le même modèle que notre dépôt de paquets AIX — une infrastructure qui distribue déjà plus de 30 paquets open source à des systèmes AIX dans le monde entier.

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

Le CI/CD tourne sur GitLab : chaque push régénère les métadonnées APT et déploie automatiquement. Tous les paquets compilés sur du vrai matériel IBM POWER — pas de compilation croisée, pas d’émulation. Le code source complet est sur GitLab sous licence Apache 2.0.

Feuille de route

La suite pour vLLM sur IBM POWER

• Plus de modèles testés — Llama, Mistral, Phi, Granite. Benchmarks systématiques par famille de modèles.
• llama.cpp pour ppc64le — Modèles GGUF quantifiés pour une empreinte mémoire encore plus faible. Déjà disponible pour AIX.
• Support Ubuntu 24.04 et Debian 12 — Extension du paquet aux dernières versions LTS.
• Variantes optimisées pour POWER10/11 — Approfondissement du tuning MMA. Nos 13,9 tok/s par cœur actuels sont un point de départ, pas un plafond.
• GEMM int8 bout en bout — Finalisation de la voie MMA pour les modèles quantifiés, ce qui devrait améliorer le débit.