Open-gpu-kernel-modules

Source.

Prérequis

• Au moins deux GPU NVIDIA grand public dont la fonction P2P est désactivée par le pilote officiel et prise en charge par le pilote modifié (architecture Turing ou plus récente). Il est recommandé d'utiliser des GPU de même architecture ou de même génération.
• Recommandé : activer l’option Above 4G Decoding dans le BIOS de la carte mère, particulièrement avec plusieurs GPU. Activer également Resizable BAR si la plateforme le permet.
• Recommandé : utiliser un démarrage en mode UEFI et désactiver le CSM. Cette configuration facilite la gestion de plusieurs GPU, l’allocation des ressources PCIe au-dessus de 4 Gio via Above 4G Decoding et l’utilisation éventuelle de Resizable BAR

Activer le mode de passthrough DMA pour l’IOMMU

L’IOMMU doit être configuré en mode passthrough (iommu=pt), sans traduction d’adresses. Dans le cas contraire, les transferts DMA passeront par les tables de pagination de l’IOMMU et échoueront. Cette configuration est potentiellement très dangereuse si la machine exécute des logiciels non fiables ou utilise des périphériques auxquels vous ne faites pas confiance.

• On édite Grub :

# vi /etc/default/grub

On ajoute à la variable GRUB_CMDLINE_LINUX_DEFAULT les options suivantes :

• Sur plateforme Intel : intel_iommu=on iommu=pt

...
GRUB_CMDLINE_LINUX_DEFAULT="quiet intel_iommu=on iommu=pt"
...

• Sur plateforme AMD : amd_iommu=on iommu=pt

...
GRUB_CMDLINE_LINUX_DEFAULT="quiet amd_iommu=on iommu=pt"
...

• On met à jour GRUB :

# update-grub

• On redémarre :

# reboot

• Après redémarrage, on vérifie que les paramètres sont bien appliqués :

# cat /proc/cmdline

Recommandé : vérifier et désactiver ACS sur les ports PCIe concernés

Lorsque l’ACS est activé sur les ports racine ou les bridges PCIe, le trafic GPU à GPU peut être redirigé vers le complexe racine du processeur, ce qui réduit fortement la bande passante P2P.

Tous les ports PCIe n’exposent cependant pas nécessairement ACS. Il faut donc commencer par identifier les ports utilisés par les GPU, puis vérifier si ACS est présent et actif sur ceux-ci.

Identifier les ports PCIe utilisés par les GPU

• On affiche la topologie PCIe :

# lspci -tv

Exemple de résultat :

...
-[0000:00]-+-00.0  Intel Corporation 8th Gen Core Processor Host Bridge/DRAM Registers
           +-01.0-[01]--+-00.0  NVIDIA Corporation GA106 [GeForce RTX 3060 Lite Hash Rate]
           |            \-00.1  NVIDIA Corporation GA106 High Definition Audio Controller
           +-01.1-[02]--+-00.0  NVIDIA Corporation GA106 [GeForce RTX 3060 Lite Hash Rate]
           |            \-00.1  NVIDIA Corporation GA106 High Definition Audio Controller
...

Dans cet exemple, les deux GPU sont respectivement connectés aux ports PCIe 0000:00:01.0 et 0000:00:01.1.

Vérifier l’état d’ACS

• On vérifie si les ports concernés exposent ACS :

# lspci -s 0000:00:01.0 -vv | grep -E 'Access Control Services|ACSCap|ACSCtl'
# lspci -s 0000:00:01.1 -vv | grep -E 'Access Control Services|ACSCap|ACSCtl'

Si aucune ligne n’est retournée, le port concerné n’expose pas ACS et aucune modification n’est nécessaire.

Si ACS est présent, une sortie de ce type peut apparaître :

Capabilities: [140 v1] Access Control Services
        ACSCap: SrcValid+ TransBlk+ ReqRedir+ CmpltRedir+ UpstreamFwd- EgressCtrl- DirectTrans-
        ACSCtl: SrcValid+ TransBlk- ReqRedir+ CmpltRedir+ UpstreamFwd- EgressCtrl- DirectTrans-

Les indicateurs ReqRedir+ et CmpltRedir+ indiquent que les fonctions de redirection ACS sont activées.

Si ces indicateurs sont actifs sur un port situé sur le chemin entre les GPU, il est recommandé de désactiver la redirection ACS.

Via le BIOS

Certaines cartes mères permettent de désactiver directement ACS sur les ports PCIe depuis le BIOS. Lorsqu’elle est disponible, cette méthode est à privilégier.

Via le noyau Linux

Le noyau Linux permet de désactiver les fonctions de redirection ACS sur des ports PCIe précis avec l’option pci=disable_acs_redir=. Cette méthode est disponible avec le noyau Debian standard et ne nécessite pas de patch.

• On édite GRUB :

# vi /etc/default/grub

On ajoute à la variable GRUB_CMDLINE_LINUX_DEFAULT l’option pci=disable_acs_redir= suivie de l’adresse des ports PCIe concernés :

...
GRUB_CMDLINE_LINUX_DEFAULT="quiet intel_iommu=on iommu=pt pci=disable_acs_redir=0000:00:01.0;0000:00:01.1"
...

Plusieurs ports peuvent être indiqués en les séparant par un point-virgule.

• On met à jour GRUB :

# update-grub

• On redémarre :

# reboot

• Après redémarrage, on vérifie que l’option a bien été appliquée :

# cat /proc/cmdline

• On vérifie ensuite à nouveau l’état ACS des ports concernés :

# lspci -s 0000:00:01.0 -vv | grep -E 'Access Control Services|ACSCap|ACSCtl'
# lspci -s 0000:00:01.1 -vv | grep -E 'Access Control Services|ACSCap|ACSCtl'

Si ACS est présent, les indicateurs ReqRedir et CmpltRedir doivent désormais apparaître désactivés (-).

Installation

Pilote NVIDIA

On installe la version du pilote NVIDIA utilisée par open-gpu-kernel-modules, ici la version 610.43.03 :

# apt update && apt upgrade
# apt install linux-headers-$(uname -r)
# mkdir -p /opt/nvidia
# cd /opt/nvidia
# wget https://us.download.nvidia.com/XFree86/Linux-x86_64/610.43.03/NVIDIA-Linux-x86_64-610.43.03.run
# sh NVIDIA-Linux-x86_64-610.43.03.run

Lors du choix du type de module noyau, sélectionner la version MIT/GPL (Open Kernel Modules).

Il est préférable de refuser l'enregistrement des modules auprès de DKMS, afin d'éviter que les modules NVIDIA officiels reconstruits automatiquement ne prennent la priorité sur ceux modifiés par open-gpu-kernel-modules :

Would you like to register the kernel module sources with DKMS? This will allow DKMS to automatically build a new module, if your kernel changes later.
-> No

Sans DKMS, les modules NVIDIA devront être recompilés après une mise à jour du noyau. Il faudra alors relancer le script d'installation de open-gpu-kernel-modules pour le nouveau noyau.

Installation du projet

On clone le dépôt dans /opt :

# cd /opt
# git clone https://github.com/aikitoria/open-gpu-kernel-modules.git
# cd open-gpu-kernel-modules

On lance ensuite le script d’installation fourni par le projet :

# ./install.sh

Une fois l’installation terminée, on redémarre la machine :

# reboot

Vérification de l'installation

• On vérifie que le P2P est bien activé en lecture et en écriture :

# nvidia-smi topo -p2p r
# nvidia-smi topo -p2p w

Exemple de résultat avec deux GPU :

        GPU0    GPU1
 GPU0   X       OK
 GPU1   OK      X

La valeur OK entre les GPU indique que le P2P est disponible dans les deux sens.

Benchmark CUDA

• On peut installer les outils de benchmark CUDA. Le CUDA Toolkit doit être installé au préalable :

# cd /opt
# git clone https://github.com/NVIDIA/cuda-samples.git
# cd /opt/cuda-samples
# export PATH=/usr/local/cuda-13.3/bin:$PATH
# export LD_LIBRARY_PATH=/usr/local/cuda-13.3/lib64:${LD_LIBRARY_PATH}
# cmake -S . -B build -DCMAKE_CUDA_COMPILER=/usr/local/cuda-13.3/bin/nvcc
# cmake --build build --target p2pBandwidthLatencyTest -j$(nproc)

La version 13.3 est à adapter à la version du CUDA Toolkit installée.

Puis on lance le benchmark :

# /opt/cuda-samples/build/cpp/5_Domain_Specific/p2pBandwidthLatencyTest/p2pBandwidthLatencyTest

Exemple de résultat :

P2P Connectivity Matrix
     D\D     0     1
     0       1     1
     1       1     1
Unidirectional P2P=Disabled Bandwidth Matrix (GB/s)
   D\D     0      1
     0 331.67   3.14
     1   3.15 333.23
Unidirectional P2P=Enabled Bandwidth (P2P Writes) Matrix (GB/s)
   D\D     0      1
     0 303.04   6.60
     1   6.60 333.44
Bidirectional P2P=Disabled Bandwidth Matrix (GB/s)
   D\D     0      1
     0 317.19   4.63
     1   4.60 333.87
Bidirectional P2P=Enabled Bandwidth Matrix (GB/s)
   D\D     0      1
     0 317.38  12.47
     1  12.47 334.05
P2P=Disabled Latency Matrix (us)
   GPU     0      1
     0   1.38  14.76
     1  12.29   1.35

   CPU     0      1
     0   1.62   4.69
     1   4.38   1.57
P2P=Enabled Latency (P2P Writes) Matrix (us)
   GPU     0      1
     0   1.38   0.82
     1   0.80   1.34

   CPU     0      1
     0   1.92   1.31
     1   1.35   1.66

Dans cet exemple, avec deux RTX 3060 reliées en PCIe 3.0 x8/x8 :

• Bande passante unidirectionnelle GPU à GPU :
  • sans P2P : environ 3,14 à 3,15 GB/s ;
  • avec P2P : 6,60 GB/s ;
  • soit un gain d'environ ×2,1.

• Bande passante bidirectionnelle GPU à GPU :
  • sans P2P : environ 4,6 GB/s ;
  • avec P2P : 12,47 GB/s ;
  • soit un gain d'environ ×2,7.

• Latence GPU à GPU :
  • sans P2P : environ 12 à 15 µs ;
  • avec P2P : environ 0,8 µs ;
  • soit une réduction de la latence d'environ ×15 à ×18.

Le programme p2pBandwidthLatencyTest permet surtout de vérifier le fonctionnement du P2P et de comparer les transferts avec et sans accès direct. NVIDIA précise que les CUDA Samples ne sont pas destinés à fournir des mesures de performances absolues.

Benchmark avec BeelLlama

Exemple de benchmark réel avec deux RTX 3060 12 Go limitées à 140 W.

• Sans P2P :

# /opt/beellama.cpp/build/bin/llama-bench -m /opt/models/Qwen3.6-27B-MTP-GGUF/UD-Q4_K_XL/Qwen3.6-27B-UD-Q4_K_XL.gguf -ngl 999 -sm tensor -ts 1/1 -t 4 -b 1024 -ub 1024 -fa on --load-mode none -ctk kvarn6 -ctv kvarn6 --kv-tail-tokens 1024 -p 65536 -n 256 -r 5

• Avec P2P :

# GGML_CUDA_P2P=1 /opt/beellama.cpp/build/bin/llama-bench -m /opt/models/Qwen3.6-27B-MTP-GGUF/UD-Q4_K_XL/Qwen3.6-27B-UD-Q4_K_XL.gguf -ngl 999 -sm tensor -ts 1/1 -t 4 -b 1024 -ub 1024 -fa on --load-mode none -ctk kvarn6 -ctv kvarn6 --kv-tail-tokens 1024 -p 65536 -n 256 -r 5

Résultats :

Test	Sans P2P	Avec P2P	Gain
pp65536	558,19 t/s	560,92 t/s	+0,49 %
tg256	28,35 t/s	28,45 t/s	+0,35 %

Le gain dans llama-bench reste donc faible sur cette configuration à deux GPU, malgré l'amélioration importante de la bande passante et de la latence mesurée par le benchmark CUDA. Cela indique que les transferts GPU à GPU ne constituent pas ici le principal facteur limitant.

Avec davantage de GPU, notamment lorsqu'ils sont reliés au même switch PCIe de type PLX, l'intérêt du P2P peut devenir plus important : une partie des échanges GPU à GPU peut alors rester à l'intérieur du switch PCIe au lieu de transiter par la mémoire système. Le gain réel dépend cependant du logiciel, du mode de répartition utilisé et de la topologie PCIe.