Tous les articles

Lire l’énergie GPU au lieu de l’estimer, sur un MI210 d’AMD

NVML ne fournit une valeur de puissance que toutes les 100 ms, si bien que mon connecteur Kokkos ne voyait pas les noyaux courts. Les GPU AMD exposent à la place un compteur d’énergie cumulée. Sur un MI210, il avance à peu près chaque milliseconde, mais une lecture coûte un tiers de milliseconde, ce qui décide de la façon dont un profileur doit s’en servir. Mesuré avec lui, fdbscan-densebox d’ArborX prend 38 % de temps et 42 % d’énergie de moins que fdbscan.

Le billet précédent se terminait sur une limite. NVML, chez NVIDIA, donne une valeur de puissance toutes les 100 ms qui ne couvre que les 25 dernières millisecondes de l’intervalle : un connecteur Kokkos Tools construit dessus peut imputer l’énergie à de longues régions, jamais à un noyau de quelques millisecondes. En octobre 2026, j’ai eu accès à illyad, un nœud du cluster Frank de l’Université de l’Oregon : deux AMD Instinct MI210 et un H100, sur le nœud où les exécutions du poster ont été faites. Les GPU AMD ne vous obligent pas à intégrer une puissance. Via AMD SMI, ils exposent un compteur de l’énergie consommée par le GPU depuis le chargement du pilote, et la question était de savoir à quoi ce compteur sert vraiment.

Ce que donne le compteur

amdsmi_get_energy_count renvoie trois nombres : un accumulateur, sa résolution et un horodatage. Le produit des deux premiers donne des joules. Sur le MI210, la résolution vaut exactement 15,3 µJ, le compteur se lit sans droits root, et sur toutes les sondes comme sur les 140 033 échantillons de l’étude ci-dessous, il n’a jamais reculé. Il repart en revanche de zéro quand le pilote est rechargé : il affichait 33,9 MJ une semaine, et 4,4 MJ après le redémarrage du nœud.

Le chiffre intéressant, c’est la fréquence à laquelle il bouge. Lu en boucle, il change de valeur environ toutes les 1,2 ms, et l’horodatage firmware qu’il renvoie avance d’autant. Sous charge, ces paliers ressemblent à ceci :

0 1 2 3 0 5 10 15 20 énergie depuis la première lecture (J) temps (ms) lu par un thread de période 10 ms une nouvelle valeur environ toutes les 1,2 ms
Lectures brutes du compteur d’un MI210 qui enchaîne des noyaux FMA, les 22 premières millisecondes de la sonde. Chaque point est une nouvelle valeur. Les lignes pointillées marquent les lectures d’un thread d’échantillonnage de période 10 ms.

Avec NVML, l’énergie est une estimation : on intègre une courbe qu’on ne voit qu’un quart du temps. Ici, l’énergie entre deux lectures est la différence de deux valeurs du compteur. Rien de ce que le GPU fait entre les deux n’est perdu.

Une lecture coûte un tiers de milliseconde

La façon évidente d’utiliser un tel compteur est celle qui échoue avec NVML : le lire quand une région commence, le relire quand elle se termine, soustraire. Avec un compteur, ce serait même juste. C’est trop lent.

Coût d’un appel à amdsmi_get_energy_count sur le MI210, ROCm 7.1.1. Plages sur les sondes au repos, avec un contexte HIP ouvert, et sous charge.
appelsmédianep99
enchaînés0,26 à 0,29 ms0,51 à 0,60 ms
espacés de 10 ms0,47 à 0,56 ms0,88 à 0,95 ms

Une demi-milliseconde par lecture, c’est plus long que beaucoup de noyaux. Lire le compteur à chaque borne de région coûterait plus que certaines des régions mesurées. Le compteur doit donc être lu comme NVML : par un thread à part, à période fixe. À 10 ms, ce thread passe environ 5 % d’un cœur dans AMD SMI.

Pourquoi un appel 10 ms après le précédent coûte deux fois plus qu’un appel juste après, on le voit côté pilote. Lire le même compteur directement dans gpu_metrics, dans sysfs, prend 42 µs, et la valeur y change toutes les 1,000 ms, presque à la microseconde près. Mon interprétation, que je n’ai pas vérifiée dans le code du pilote : amdgpu garde une copie de la table de mesures du firmware pendant une milliseconde, et la première lecture après son expiration attend une copie fraîche. Un thread qui lit toutes les 10 ms paie donc toujours cette attente. Le pas de 1,2 ms vu à travers AMD SMI, c’est cette milliseconde plus le temps jusqu’au prochain appel de ~0,3 ms. Deux processus qui lisent en même temps ne sont pas sérialisés ; leur p99 augmente d’environ moitié.

Que coûte la période de 10 ms en précision ? Moins qu’il n’y paraît. L’énergie entre deux échantillons est exacte ; seul son partage à une borne de région est interpolé. À 200 W, c’est au plus environ 2 J par borne : moins de 0,1 % d’une région de plusieurs secondes, beaucoup pour un noyau de quelques millisecondes. Le matériel bouge chaque milliseconde ; le profileur voit toutes les dix.

L’étude DBSCAN, à nouveau, sur le MI210

J’ai refait l’étude de cas du poster avec ce compteur : la même entrée HACC de 497 838 606 points, les mêmes paramètres, 64 exécutions de chaque implémentation d’ArborX, en alternance, via un connecteur expérimental qui lit le compteur toutes les 10 ms et écrit le format de trace d'energy-dashboard-for-kokkos.

La région DBSCANCalculation sur un MI210, médianes sur 64 exécutions de chaque implémentation.
implémentationtempsénergiepuissance moyenne
fdbscan6,948 s1465 J211 W
fdbscan-densebox4,309 s846 J197 W

L’implémentation dense prend 38,0 % de temps et 42,2 % d’énergie en moins, et les intervalles bootstrap sur les exécutions font un dixième de point de large. Les exécutions sont aussi remarquablement régulières : les quartiles de fdbscan s’étendent sur 11 ms et 3 J, et aucune exécution n’est plus de 30 % plus lente que sa médiane. Rien de comparable au premier lot lent de la série H100.

Le résultat a la même forme que sur le H100 : l’implémentation la plus rapide est aussi la plus sobre, et l’écart d’énergie dépasse l’écart de temps parce que la puissance moyenne baisse aussi, de 6,8 % ici. Un profil en temps sous-estime encore le gain.

Ce que ça ne montre pas

Il est tentant de mettre ce tableau à côté de celui du poster et d’en tirer une comparaison entre AMD et NVIDIA. Elle ne tiendrait pas. Les chiffres du H100 viennent d’une puissance échantillonnée via NVML, d’un ArborX de juillet 2025 et du Kokkos de l’époque ; ceux-ci viennent du compteur d’énergie, de l’ArborX d’octobre 2026 et de Kokkos 5.0.2. L’écart entre les deux implémentations est plus grand ici, 38 % contre 19 % en temps, et je ne sais pas dire quelle part revient au GPU et quelle part à quinze mois de développement d’ArborX.

Deux autres limites. Je n’ai pas comparé le compteur à un wattmètre externe : les joules absolus valent ce que vaut la télémétrie d’AMD ; les comparaisons entre implémentations n’en dépendent pas. Et la machine a changé sous mes pieds : pendant l’étude, le MI210 consommait environ 41 W au repos, et après un redémarrage une semaine plus tard, le même GPU consommait 58 W au repos, fréquences au maximum. Je ne sais pas pourquoi. Les chiffres de l’étude appartiennent au premier état.

La suite

Le connecteur lit le compteur à travers une seule classe, seul code à appeler AMD SMI, conçue pour s’insérer dans l’organisation en providers de l’outillage énergie proposé pour Kokkos Tools. Il a pour l’instant son propre thread d’échantillonnage ; la version upstream devra utiliser le démon en revue dans Kokkos Tools (#350), et attend donc sa fusion. La prochaine mesure est celle qui rendrait la comparaison équitable : le même build d’ArborX sur le H100 du même nœud, lu via le compteur d’énergie cumulée de NVML plutôt que sa valeur de puissance.

Le connecteur, les sondes, les données brutes et les scripts qui recalculent chaque chiffre de ce billet sont sur GitHub : mi210-energy-counter. Cette recherche a utilisé des ressources du cluster Frank de l’Université de l’Oregon.