Auteur

Killian Pluenet

Développeur C/C++, systèmes embarqués & bas niveau

Killian Pluenet est développeur C/C++ spécialisé en systèmes embarqués et programmation bas niveau. Il conçoit des firmwares sur architectures STM32 et passe son temps à comprendre ce qui se passe réellement sous le capot : de la communication entre composants à l'optimisation des ressources sur environnements contraints. Il est membre du Sophia Hack Lab, le hackerspace d'Antibes.

En parallèle, il développe Memtide, un orchestrateur de mémoire RAM et CXL : un sujet qui mêle gestion mémoire fine, architectures modernes et performance à très bas niveau. C'est ce même regard (mémoire, bande passante, ce qui se passe sous les abstractions) qu'il porte sur LeCompute : décortiquer le compute IA du silicium au code, sans hype.

Site personnel : killianpluenet.com

  • C / C++
  • Systèmes embarqués
  • Programmation bas niveau
  • Architecture mémoire & CXL

Articles de Killian 42

Silicon

BlueField-4 face à Pensando Salina : le DPU entre dans le chemin de l'inférence

BlueField-4 et Pensando Salina ne calculent aucun token. Ils déplacent le réseau, le stockage, la sécurité et certains transferts du KV cache hors du CPU hôte. Voici le chemin de données qui peut libérer le GPU, ou seulement déplacer le goulot.

13 min de lecture
  • BlueField-4
  • Pensando Salina
  • DPU
  • KV cache

Runtimes

MLPerf RAG mesure enfin toute la chaîne, pas encore le service

MLPerf E2E-RAG chronomètre l'ingestion, la recherche, le reranking et quatre rôles LLM dans une boucle multi-hop. Son débit est comparable, mais son scénario offline et sa précision de référence à 35 % bornent le verdict.

16 min de lecture
  • MLPerf
  • RAG
  • MLCommons
  • GPT-OSS

Silicon

UALink 2.0 contre NVLink 6 : quand le réseau calcule l'all-reduce

UALink 2.0 standardise le calcul dans le réseau ; NVLink 6 l'intègre dans ses switches. Voici ce que ce mécanisme change, et pourquoi Helios et Vera Rubin restent impossibles à départager.

16 min de lecture
  • UALink 2.0
  • UALoE
  • NVLink 6
  • in-network compute

Runtimes

DWDP pour les MoE : déplacer les poids plutôt que les tokens

Le parallélisme d'experts déplace les tokens vers les poids. DWDP inverse le trajet, précharge les poids distants et supprime la synchronisation entre rangs. Le pari fonctionne, mais dans un régime étroit.

12 min de lecture
  • DWDP
  • MoE
  • SGLang
  • TensorRT-LLM

Silicon

RTX PRO 6000 ou trois RTX 5090 : 96 Go ne font pas une mémoire unique

Une RTX PRO 6000 et trois RTX 5090 totalisent chacune 96 Go de GDDR7. Pour un LLM, cette égalité s'arrête au nombre : pool unique, modèle réparti et répliques indépendantes ne paient pas les mêmes coûts.

13 min de lecture
  • RTX PRO 6000
  • RTX 5090
  • LLM local
  • multi-GPU

Runtimes

vLLM 0.27 : le KV cache devient pair-à-pair

vLLM 0.27 permet à chaque moteur de servir son KV cache CPU à un autre pair via NIXL, ajoute le filtrage par requête et expose des événements routables. Le cache change d'échelle, mais pas sans coût réseau.

13 min de lecture
  • vLLM 0.27
  • KV cache
  • NIXL
  • Offloading

Silicon

RTX Spark sous Windows : CUDA est natif, la pile LLM ne l'est pas encore

RTX Spark apporte jusqu'à 128 Go de mémoire unifiée et CUDA natif à Windows on Arm. Au 12 août, le pilote et CUDA 13.4 restent en Developer Preview, TensorRT-RTX est prêt, tandis que PyTorch, llama.cpp et la pile de serving sont encore à qualifier.

13 min de lecture
  • RTX Spark
  • Windows on Arm
  • CUDA 13.4
  • TensorRT-RTX

Runtimes

Kimi K3 ouvre 2,8 T de paramètres, pas un modèle local

Kimi K3 active 104 milliards de paramètres sur 2,8 billions, combine KDA et MLA sur un contexte d'un million de tokens, puis demande un nœud de huit B300 ou huit MI355X dans les recettes vLLM. Anatomie de ce que les poids ouverts changent réellement.

12 min de lecture
  • Kimi K3
  • Moonshot AI
  • MoE
  • KDA

Runtimes

AMD Infera face à Dynamo et llm-d : le routeur prend le contrôle

AMD lance Infera pour router les requêtes selon le KV cache, séparer prefill et decode, puis déporter le cache hors du GPU. Face à Dynamo et llm-d, la différence se joue moins sur les fonctions promises que sur le périmètre réellement livré.

14 min de lecture
  • AMD Infera
  • NVIDIA Dynamo
  • llm-d
  • KV cache

Kernel & Perf

CUDA Tile : programmer le GPU à la tuile, plus au thread

Depuis quinze ans, un kernel GPU performant veut dire orchestrer des milliers de threads à la main. CUDA Tile remonte la programmation d'un cran, la tuile, et confie le reste au compilateur. Mécanique, et ce que ça change vraiment.

12 min de lecture
  • CUDA Tile
  • cuTile
  • Tile IR
  • Kernels GPU

Runtimes

Servir DeepSeek-V4 sans casser l'exactitude

DeepSeek-V4 compresse son attention si fort que le servir mal ne plante pas : ça dégrade l'exactitude en silence. Versions minimales par runtime, le flag qui restaure GSM8K, et comment le vérifier.

12 min de lecture
  • DeepSeek-V4
  • vLLM
  • SGLang
  • TensorRT-LLM

Kernel & Perf

sched_ext : écrire l'ordonnanceur de votre inférence en eBPF

eBPF vous a montré le thread coincé dans la run-queue qui affame le GPU. chrt et cpuset sont des marteaux. sched_ext laisse charger un ordonnanceur CPU sur mesure, en eBPF, sans patch ni redémarrage, taillé pour le prefill et le decode.

11 min de lecture
  • sched_ext
  • eBPF
  • Ordonnancement
  • Noyau Linux

Silicon

RTX Spark : le cousin Windows du DGX Spark, et le mur des 273 Go/s

Le RTX Spark (N1X) n'est pas un DGX Spark renommé : c'est le SoC Grace-Blackwell sous Windows on Arm, 128 Go de mémoire unifiée. Pourquoi ce sont les ~273 Go/s, et non le « pétaflop », qui décident de ce qu'il sait faire.

19 min de lecture
  • RTX Spark
  • DGX Spark
  • Grace-Blackwell
  • Mémoire unifiée

Silicon

Combien de VRAM pour faire tourner un LLM en local ?

Combien de VRAM faut-il pour un LLM en local ? La règle des ~2 Go par milliard de paramètres, le poids du KV cache, l'effet de la quantification, et ce qui tient vraiment sur votre carte.

8 min de lecture
  • VRAM
  • LLM local
  • Quantification
  • KV cache

Silicon

Vera Rubin : la fin de l'inférence GPU homogène

NVIDIA Vera Rubin n'est pas qu'un GPU plus rapide : l'inférence éclate en trois tiers (prefill GPU, decode LPU, orchestration CPU) coordonnés par Dynamo.

19 min de lecture
  • NVIDIA Rubin
  • Vera CPU
  • HBM4
  • Groq LPU

Coûts

Coût d'inférence LLM : API, GPU cloud ou auto-hébergement ?

Le vrai coût de l'inférence LLM en 2026 : prix des API au token, location de GPU, auto-hébergement. Calculez votre point de bascule, chiffres et sources à l'appui.

11 min de lecture
  • Coût d'inférence
  • GPU cloud
  • API LLM
  • Auto-hébergement

Silicon

RTX 5090 vs H100 : quelle carte pour un LLM en local ?

RTX 5090 vs H100 pour faire tourner un LLM en local : 32 Go GDDR7 face à 80 Go HBM3, ce qui tient vraiment en VRAM, et pourquoi ce ne sont pas les mêmes produits.

8 min de lecture
  • RTX 5090
  • H100
  • LLM local
  • VRAM

Silicon

CUDA vs ROCm en 2026 : l'écart réel en production IA

CUDA vs ROCm en 2026 : le débat n'est plus « est-ce que ROCm marche » mais « quel écart reste-t-il ». Versions, parité framework, vrais verrous, sources.

8 min de lecture
  • CUDA
  • ROCm
  • AMD
  • NVIDIA

Runtimes

vLLM vs llama.cpp vs TensorRT-LLM : quel runtime choisir ?

Trois runtimes d'inférence LLM, trois philosophies : débit serveur, déploiement local, performance verrouillée NVIDIA. Matrice de décision claire pour choisir.

8 min de lecture
  • vLLM
  • llama.cpp
  • TensorRT-LLM
  • Inférence

Runtimes

KV cache : pourquoi votre LLM sature la mémoire

Le KV cache explique pourquoi un LLM consomme autant de VRAM. Définition, calcul de taille concret, PagedAttention, quantification FP8 et prefix caching.

9 min de lecture
  • KV cache
  • PagedAttention
  • Quantification
  • Mémoire

Kernel & Perf

eBPF et perf : observer une stack d'inférence LLM

Le GPU est à 30 %, pourquoi ? eBPF et perf diagnostiquent le côté hôte d'une stack (ordonnancement, page faults, I/O), là où les abstractions s'arrêtent.

10 min de lecture
  • eBPF
  • perf
  • Observabilité
  • Noyau Linux

Runtimes

llama.cpp expliqué : GGUF, quantification et kernels

Comment llama.cpp fait tenir des modèles de dizaines de milliards de paramètres sur du matériel grand public : format GGUF, quantification et chemin d'un token.

8 min de lecture
  • llama.cpp
  • GGUF
  • Quantification
  • Quantization

Silicon

AMD MI355X vs NVIDIA B200/B300 : le vrai match en 2026

AMD MI355X face à NVIDIA B200 et B300 : mémoire, bande passante, FP4 et le vrai écart, le scale-up NVLink et le logiciel. Comparatif sourcé, mi-2026.

6 min de lecture
  • AMD MI355X
  • NVIDIA B200
  • Blackwell
  • CDNA 4

Edge AI

Jetson Orin et edge AI : LLM, vision et limites mémoire

Ce qui tourne sur un Jetson Orin hors datacenter : LLM quantifiés, vision temps réel, et les vraies limites, mémoire unifiée, thermique, arbitrage edge/cloud.

9 min de lecture
  • Jetson Orin
  • Edge AI
  • Embarqué
  • Vision