Ik llama.cpp

Prérequis

ik_llama.cpp requiert un CPU avec support AVX2 (Intel Haswell / 2013 ou plus récent). Les CPU plus anciens (ex: Ivy Bridge, Sandy Bridge) supportent AVX mais pas AVX2 et ne peuvent pas compiler ik_llama correctement.

CPUs incompatibles : Intel Xeon E5 v1/v2, Core i7 3xxx/4xxx première gen... CPUs compatibles : Intel Core i5/i7/i9 depuis 2013, Xeon E5 v3+, AMD Ryzen toutes générations Pour ces configurations, utiliser llama.cpp standard à la place.

Un GPU est recommandé, idéalement NVIDIA avec le plus de VRAM possible. ik_llama.cpp met particulièrement l’accent sur CUDA, le multi-GPU et les configurations hybrides GPU/CPU. Comme llama.cpp, il permet de répartir une partie du modèle entre GPU et CPU si la VRAM est insuffisante, au prix d’une baisse de performances. Voir ce lien pour partager un GPU dans un LXC
Les modèles peuvent fonctionner sur CPU uniquement, mais avec des performances très faibles pour les gros modèles, souvent inutilisables en pratique pour un usage interactif.
VRAM recommandée : dépend du niveau d’offload GPU et de la taille du contexte utilisé. Pour un usage optimal, prévoir environ la taille du modèle quantifié + 1 à 3 Go pour le KV cache. Il est toutefois possible de réduire la VRAM nécessaire en déportant une partie du modèle en RAM.
RAM recommandée : au minimum équivalente à la taille du modèle, idéalement 1,5 à 2 fois, notamment si une partie du modèle est exécutée sur CPU ou si l’on utilise une configuration hybride GPU/CPU.
Espace disque à prévoir en fonction du ou des modèles que vous allez utiliser ou tester. Exemples :
- qwen2.5:7b (Q4) ≈ 4–5 Go
- qwen2.5:14b (Q4) ≈ 8–10 Go
- llama3:70b (Q4) ≈ 35–40 Go
Utiliser un SSD/NVMe améliore fortement les temps de chargement des modèles.
CPU / vCPU recommandés :
- Avec GPU : 4 à 8 vCPU recommandés, notamment pour la gestion du serveur, du KV cache et d’un éventuel offload partiel CPU.
- Sans GPU : prévoir au minimum 8 à 16 vCPU, les performances restant très limitées sur les modèles importants.
Note : Q4 correspond au niveau de quantization, c’est-à-dire une réduction de la précision numérique du modèle afin de diminuer son utilisation en mémoire, notamment en VRAM. Les niveaux vont généralement de Q1 à Q8 : Q8 est le plus précis, proche du modèle original, mais aussi le plus gourmand en ressources. À l’inverse, Q1 est très léger mais fortement dégradé. En pratique, Q4 ou Q5 est généralement considéré comme le meilleur compromis entre performances, consommation de VRAM et qualité de réponse.

Installation

Prérequis système

Installer les dépendances nécessaires :

# apt update && apt upgrade
# apt install build-essential git libcurl4-openssl-dev curl libgomp1 cmake

Récupération du projet

# cd /opt
# git clone https://github.com/ikawrakow/ik_llama.cpp

Compilation

Choisir une seule méthode de compilation selon le matériel disponible.

Méthode	Description	Recommandation
CPU uniquement	Compilation sans accélération GPU.	Non testé / déconseillé pour de gros modèles.
GPU NVIDIA CUDA	Compilation avec accélération GPU via CUDA.	Recommandé avec une carte NVIDIA compatible.

En cas de changement de méthode de compilation, supprimer le dossier de compilation avant de relancer CMake :

# rm -rf /opt/ik_llama.cpp/build

Option A — CPU uniquement

Cette méthode ne nécessite pas de GPU compatible, mais les performances seront limitées.

# cd /opt/ik_llama.cpp
# cmake -B build -DGGML_NATIVE=ON
# cmake --build build --config Release -j$(nproc)

Si processeur avec instructions AVX512 (certains CPU Zen 4 / Zen 5 etc..) :

(Source)

# cmake -B build -DCMAKE_BUILD_TYPE=Release \
    -DGGML_NATIVE=ON \
    -DGGML_AVX512=ON \
    -DGGML_AVX512_VBMI=ON \
    -DGGML_AVX512_VNNI=ON \
    -DGGML_AVX512_BF16=ON
# cmake --build build --config Release

Option B — GPU NVIDIA CUDA

Cette méthode est recommandée avec une carte NVIDIA compatible CUDA.

Installation du support GPU NVIDIA CUDA

(Optionnel) Vérifier la dernière version disponible du paquet cuda-keyring :

# curl https://developer.download.nvidia.com/compute/cuda/repos/debian13/x86_64/ | grep keyring

Installer le dépôt CUDA NVIDIA :

# cd /opt
# wget https://developer.download.nvidia.com/compute/cuda/repos/debian13/x86_64/cuda-keyring_1.1-1_all.deb
# dpkg -i cuda-keyring_1.1-1_all.deb
# apt update

Installer le toolkit CUDA :

# apt install -y cuda-toolkit

Compilation avec support CUDA

Connaître les versions de nvcc installées :

# find /usr /opt -name nvcc 2>/dev/null

Compiler llama.cpp avec le support CUDA :

# cd /opt/ik_llama.cpp
# export CUDACXX=/usr/local/cuda-13.3/bin/nvcc
# cmake -B build -DGGML_NATIVE=ON -DGGML_CUDA=ON
# cmake --build build --config Release -j$(nproc)

Emplacement des binaires

Les binaires seront disponibles dans :

/opt/ik_llama.cpp/build/bin/

Mise à jour

Pour mettre à jour ik_llama.cpp, arrêter d'abord les services ou processus qui utilisent les binaires :

# pkill -f llama-server

Se placer dans le dossier du projet :

# cd /opt/ik_llama.cpp

Récupérer la dernière version du dépôt :

# git pull

Par sécurité, supprimer l'ancien dossier de compilation avant de recompiler :

# rm -rf build

Recompiler avec la même méthode que lors de l'installation.

Mise à jour CPU uniquement

# cmake -B build -DGGML_NATIVE=ON
# cmake --build build --config Release -j$(nproc)

Mise à jour GPU NVIDIA CUDA

Si nécessaire, vérifier le chemin de nvcc :

# find /usr /opt -name nvcc 2>/dev/null

Puis recompiler avec CUDA :

# export CUDACXX=/usr/local/cuda-13.3/bin/nvcc
# cmake -B build -DGGML_NATIVE=ON -DGGML_CUDA=ON
# cmake --build build --config Release -j$(nproc)

Les nouveaux binaires seront disponibles dans :

/opt/ik_llama.cpp/build/bin/

Vérifier la version compilée :

# /opt/ik_llama.cpp/build/bin/llama-server --version

Configuration

Se reporter à la page de llama.cpp

Particularités de ik_llama

Télécharger un modèle

Préférer le téléchargement via le client Hugging Face

Multi-GPU via sm graph

ik_llama.cpp dispose d'un mode de répartition multi-GPU spécifique appelé graph.

Contrairement au mode classique layer, qui répartit les couches du modèle entre les GPU, le mode graph cherche à répartir le graphe de calcul lui-même entre plusieurs GPU. L'objectif est de mieux utiliser plusieurs cartes en parallèle, notamment lorsque le modèle est trop gros pour une seule carte ou lorsque plusieurs GPU doivent travailler simultanément.

Ce mode est surtout intéressant avec plusieurs GPU. Sur une seule carte graphique, il n'a généralement pas d'intérêt.

Vérifier la disponibilité de l'option

Les options disponibles peuvent varier selon la version compilée. Vérifier d'abord que le binaire supporte bien le mode graph :

# /opt/ik_llama.cpp/build/bin/llama-server --help | grep -i "split"

ou :

# /opt/ik_llama.cpp/build/bin/llama-server --help | grep -i "graph"

Exemple simple avec deux GPU

Exemple avec deux GPU identiques :

# /opt/ik_llama.cpp/build/bin/llama-server \
    -m /models/modele.gguf \
    -ngl 999 \
    -sm graph \
    --tensor-split 12,12 \
    -c 4096 \
    -fa

Les valeurs de --tensor-split sont des proportions. Pour deux GPU identiques, on peut utiliser :

# --tensor-split 12,12

ou simplement :

# --tensor-split 1,1

Les deux indiquent une répartition équilibrée.

Exemple avec GPU de tailles différentes

Exemple avec une carte de 24 Go et une carte de 12 Go :

# /opt/ik_llama.cpp/build/bin/llama-server \
    -m /models/modele.gguf \
    -ngl 999 \
    -sm graph \
    --tensor-split 24,12 \
    -c 4096 \
    -fa

Cela indique à ik_llama.cpp de répartir davantage de charge vers la carte disposant de plus de VRAM.

Sélectionner les GPU visibles

Il est possible de limiter les GPU visibles avec `CUDA_VISIBLE_DEVICES`.

Exemple pour n'utiliser que les GPU physiques 1 et 2 :

# CUDA_VISIBLE_DEVICES=1,2 /opt/ik_llama.cpp/build/bin/llama-server \
    -m /models/modele.gguf \
    -ngl 999 \
    -sm graph \
    --tensor-split 1,1 \
    -c 4096 \
    -fa

Attention : lorsque CUDA_VISIBLE_DEVICES est utilisé, les GPU sont renumérotés par CUDA.

Ainsi :

# CUDA_VISIBLE_DEVICES=1,2

signifie que le GPU physique 1 devient le GPU 0 pour ik_llama.cpp, et que le GPU physique 2 devient le GPU 1.

Choisir le GPU principal

Le paramètre --main-gpu permet de choisir le GPU principal utilisé par llama.cpp / ik_llama.cpp pour certaines allocations.

Exemple :

# /opt/ik_llama.cpp/build/bin/llama-server \
    -m /models/modele.gguf \
    -ngl 999 \
    -sm graph \
    --tensor-split 1,1 \
    --main-gpu 0 \
    -c 4096 \
    -fa

Si le GPU 0 est utilisé par l'affichage ou par un autre service, il peut être utile de tester un autre GPU principal.

Benchmark

Comparer d'abord un seul GPU :

# CUDA_VISIBLE_DEVICES=0 /opt/ik_llama.cpp/build/bin/llama-bench \
    -m /models/modele.gguf \
    -ngl 999 \
    -c 4096 \
    -fa

Puis deux GPU en mode graph :

# CUDA_VISIBLE_DEVICES=0,1 /opt/ik_llama.cpp/build/bin/llama-bench \
    -m /models/modele.gguf \
    -ngl 999 \
    -sm graph \
    --tensor-split 1,1 \
    -c 4096 \
    -fa

Les valeurs à comparer sont principalement :

pp : prompt processing
tg : token generation

Surveillance de la VRAM

Pendant les tests, surveiller l'utilisation mémoire :

# watch -n 1 nvidia-smi

En cas d'erreur CUDA out of memory, essayer :

réduire -c ;
réduire -b ;
réduire -ub ;
ajuster --tensor-split ;
réduire -ngl ;
utiliser un quant plus léger.

Remarques

Le mode graph est surtout utile en multi-GPU.
Les gains dépendent fortement du modèle, du quant, du PCIe, du contexte et du nombre de GPU.
Deux GPU identiques sont plus simples à configurer.
Avec des GPU différents, il peut être nécessaire de tester plusieurs valeurs de --tensor-split.
Le mode graph peut évoluer rapidement selon les versions de ik_llama.cpp. Il est donc recommandé de vérifier les options disponibles avec --help après chaque mise à jour.