IA ouverte et locale

Accélérez l'inférence de llama.cpp avec une seule variable d'environnement Linux

La configuration de GLIBC_TUNABLES pour activer les pages géantes réduit les fautes de page dans llama.cpp, offrant jusqu'à 21 % de débit supplémentaire sur les GPU H100.

Illustration comparant les petites pages mémoire de 4 Ko aux grandes pages de 2 Mo sur un circuit imprimé
Illustration générée pour cet article

Traduit automatiquement depuis l'original anglais.

Une modification simple de la configuration liée à la gestion de la mémoire sous Linux a permis d'accélérer considérablement le service local de grands modèles de langage. En définissant une seule variable d'environnement, les ingénieurs utilisant llama.cpp et Ollama peuvent réduire la surcharge CPU due à l'allocation mémoire, ce qui entraîne des temps de réponse plus rapides et un débit de requêtes supérieur sans modifier le code source.

Ce qui s'est passé

Les ingénieurs de Tensward, une entreprise d'outils open source spécialisée dans l'optimisation de l'inférence LLM, ont découvert que leur serveur llama.cpp passait beaucoup de temps à attendre que le noyau Linux alloue de la mémoire. Le goulot d'étranglement ne se situait pas au niveau du GPU, mais dans la manière dont le système d'exploitation gérait les demandes de RAM pour stocker les instantanés de conversation. En activant les « pages géantes » via un paramètre ajustable de glibc, ils ont réduit le nombre de fautes de page par requête d'environ 145 000 à seulement 1 850 sur un GPU NVIDIA H100.

L'équipe a testé cet ajustement sur Qwen3.8-27B, un modèle largement utilisé dans les déploiements d'IA locaux. La modification n'a nécessité aucune recompilation du code ni privilèges root, mais uniquement l'ajout de GLIBC_TUNABLES=glibc.malloc.hugetlb=1 avant le démarrage du processus serveur. Cet ajustement indique à l'allocateur de mémoire de demander des blocs contigus plus grands, minimisant ainsi l'intervention du noyau lors des opérations d'écriture.

Les gains de performance variaient selon le matériel et la charge de travail. Sur un H100 traitant des prompts appelant des outils, le débit a augmenté de 21 %, et le temps médian jusqu'au premier jeton a diminué de 22 %. Même sur un matériel plus lent comme le NVIDIA L4, les scénarios de chat simple ont vu le premier jeton arriver 22 % plus tôt, bien que les améliorations globales du débit aient été plus modestes, à 3,5 %. Ces résultats suggèrent que le bénéfice est particulièrement marqué lorsque la latence d'allocation mémoire du CPU représente une part significative du temps total de traitement de la requête.

Comment cela fonctionne

Linux alloue généralement la mémoire en petits morceaux de 4 Ko appelés pages. Lorsqu'un programme comme llama.cpp écrit pour la première fois dans une nouvelle page, le noyau doit intervenir pour la configurer, un événement connu sous le nom de faute de page. Pour les grands modèles, la sauvegarde de l'état de la conversation implique la création d'instantanés pouvant atteindre 150 Mo ou plus, déclenchant des centaines de milliers de ces fautes. Comme le thread gérant ces instantanés alimente également le GPU en données, chaque pause due à une faute de page bloque l'ensemble du pipeline d'inférence.

Les pages géantes permettent au système d'allouer la mémoire en blocs de 2 Mo au lieu de 4 Ko. En configurant le paramètre ajustable de glibc, l'application demande explicitement ces blocs plus grands. Cela réduit drastiquement le nombre de fois où le noyau doit interrompre l'exécution pour gérer les métadonnées de mémoire. Le résultat est un flux de données plus fluide vers le GPU, car le CPU passe moins de temps à traiter les tâches administratives de mémoire et plus de temps à préparer les entrées pour le traitement parallèle.

Détails clés

  • L'optimisation nécessite glibc version 2.35 ou plus récente, disponible sur Ubuntu 22.04 et Debian 12 ou versions ultérieures.
  • Les fautes de page sont passées d'environ 145 000 à environ 1 850 par requête sur le matériel H100 lors des tests.
  • Le débit a augmenté de 21 % pour les prompts appelant des outils sur H100, mais seulement de 6,5 % sur L4 pour la même charge de travail.
  • Les utilisateurs d'Ollama ont également constaté des bénéfices, avec des gains de performance allant de 2 % à 7 % selon la machine.
  • Cette correction ne bénéficie pas significativement aux frameworks comme vLLM ou SGLang, qui minimisent déjà les fautes de page.
  • L'utilisation de la mémoire a augmenté d'environ 0,5 Go en moyenne lors de l'exécution d'Ollama avec ce paramètre activé.

Pourquoi c'est important

Pour les développeurs créant des produits avec des LLM locaux, cette découverte souligne que la puissance du GPU n'est pas le seul déterminant de la vitesse d'inférence. À mesure que les GPU deviennent plus rapides, comme le H100 comparé au L4, le coût relatif des opérations côté CPU telles que l'allocation mémoire augmente. Un délai fixe de 0,1 seconde par requête représente un pourcentage beaucoup plus élevé du temps total sur une carte rapide que sur une carte plus lente. Cela signifie que l'optimisation des configurations au niveau du système devient de plus en plus critique à mesure que le matériel accélère.

Cette approche offre une opportunité d'ajustement à faible risque et à haut rendement pour les équipes utilisant llama.cpp ou Ollama. Puisqu'elle ne nécessite aucun changement de code et a un impact minimal sur la stabilité ou la qualité des réponses, elle peut être déployée rapidement pour améliorer l'expérience utilisateur. La réduction du temps jusqu'au premier jeton est particulièrement précieuse pour les applications interactives où la latence perçue influence la satisfaction de l'utilisateur.

Ce que vous pouvez faire

  • Vérifiez que votre système dispose de glibc 2.35 ou plus récent en exécutant ldd --version dans votre terminal.
  • Vérifiez si les pages transparentes géantes sont activées en inspectant /sys/kernel/mm/transparent_hugepage/enabled.
  • Lancez votre serveur llama.cpp avec GLIBC_TUNABLES=glibc.malloc.hugetlb=1 ajouté au début de la commande.
  • Pour Ollama, appliquez la même variable d'environnement lors du démarrage du processus ollama serve.
  • Surveillez l'efficacité en vérifiant AnonHugePages dans /proc/[pid]/smaps_rollup pour vous assurer que les pages géantes sont utilisées.
  • Comparez le nombre de fautes de page avant et après le changement en utilisant ps -o min_flt= pour quantifier la réduction.
  • #llama.cpp
  • #linux
  • #performance
  • #ollama
  • #inference

Outils de la Boutique Bytechap

$89

DocBento

Gestion documentaire auto-hébergée qui analyse chaque scan et répond avec des citations de pages.

Démo en ligne

Continuer la lecture

Tous les articles