Tous les articles

Ce que NVML peut dire d’un seul noyau

Mon outillage énergétique pour Kokkos s’arrêtait à l’échelle du GPU entier. Sur ma propre RTX 3080 Ti, j’ai mesuré à quelle fréquence changent les lectures de puissance et d’énergie de NVML, à quel point son compteur d’énergie est exact, et si les horodatages de noyaux de CUPTI permettent de répartir la puissance de la carte entre les noyaux. C’est possible, tant que les noyaux ne se partagent pas le GPU.

Le billet sur l’énergie dans Kokkos se terminait sur deux questions ouvertes. NVML est trop grossier pour imputer de l’énergie à un seul noyau, et je n’avais pas de réponse propre pour des noyaux qui tournent en même temps sur deux streams. Sur un MI210 d’AMD, un compteur d’énergie cumulée répondait à une partie de la première. Les GPU NVIDIA en ont un aussi, nvmlDeviceGetTotalEnergyConsumption, et je ne l’avais jamais mesuré. Je l’ai donc fait, sur le GPU que j’ai chez moi : une RTX 3080 Ti, pilote 610.88, sous Windows 11. Chaque sonde est un court script Python, et l’ensemble tourne en cinq minutes environ.

À quelle fréquence les valeurs changent

NVML donne trois valeurs de puissance : nvmlDeviceGetPowerUsage, l’appel qu’utilisent la plupart des outils, et deux champs de l’API de valeurs de champs, la puissance instantanée et la puissance moyenne. Je les ai lues toutes les trois, avec le compteur d’énergie, en boucle pendant 20 s, à peu près toutes les 1,3 ms sous charge, en notant chaque changement de valeur.

Temps médian entre deux changements de chaque valeur NVML sur la RTX 3080 Ti, sur 20 s de lectures.
valeursous chargeau repos
puissance usage, instantanée, moyenne500 ms500 ms ou 1 s
compteur d’énergie100 ms100 ms

Sur cette carte, les valeurs de puissance bougent deux fois par seconde. C’est cinq fois plus lent que les 100 ms rapportées par Yang, Adamek et Armour pour les GPU de centre de calcul. Une carte grand public sous Windows n’est pas un H100, et cette sonde ne dit rien d’un H100. Le compteur d’énergie, lui, bouge toutes les 100 ms, sous charge comme au repos.

Les trois valeurs de puissance ne sont pas non plus trois mesures. nvmlDeviceGetPowerUsage renvoie exactement le champ moyen, lecture pour lecture. Quand une charge démarre, le champ instantané affiche 349 W dès sa première mise à jour. La valeur que lisent la plupart des outils passe par 207 W, puis 316 W, et n’atteint 351 W qu’une seconde plus tard. Elle traîne de la même façon quand la charge s’arrête.

charge matmul active 100 200 300 0 5 10 15 20 puissance de la carte (W) temps (s) power usage (= champ moyen) champ instantané
Les trois valeurs de puissance NVML lues toutes les 0,5 s autour d’une charge matmul de 10 s. Le champ instantané suit la charge en une mise à jour ; la valeur que renvoie nvmlDeviceGetPowerUsage est une moyenne et met plusieurs mises à jour à rattraper, à la montée comme à la descente.

Le compteur, lu trop vite

Avec un compteur, la fréquence de lecture devrait être sans importance : l’énergie entre deux lectures est la différence de deux valeurs, et rien entre les deux n’est perdu. Pour le vérifier, j’ai lancé une charge matmul constante, lu le compteur à fréquence fixe pendant une durée fixe, et divisé l’énergie qu’il rapportait par cette durée, 8 s par fréquence, dans l’ordre croissant, en une seule exécution. La valeur de puissance affichait 351 W tout du long.

Puissance moyenne déduite du compteur d’énergie à chaque fréquence de lecture, sous une charge constante où la valeur de puissance affiche 351 W.
fréquence de lecturepuissance d’après le compteurpar rapport à 351 W
1 Hz338 W−4 %
2 Hz335 W−5 %
5 Hz328 W−6 %
10 Hz301 W−14 %
14 Hz301 W−14 %
19 Hz270 W−23 %
46 Hz158 W−55 %
102 Hz115 W−67 %
235 Hz29 W−92 %
766 Hz12 W−97 %

Lu une ou deux fois par seconde, le compteur s’accorde avec la valeur de puissance à 5 % près. Lu plus vite, il perd de l’énergie, et lu en boucle serrée il en perd presque tout. Je ne sais pas pourquoi, et je ne l’ai pas trouvé documenté. J’en tire une règle pratique : sur cette carte, lire le compteur rarement, sur des fenêtres d’une seconde ou plus, et jamais aux bornes des noyaux.

Répartir la puissance de la carte entre les noyaux

NVML ne voit jamais que la carte entière. CUPTI, l’interface de profilage de NVIDIA, voit les noyaux : quand chacun commence et finit. La question était de savoir si l’on peut joindre les deux. Le modèle est le plus simple possible : la puissance de la carte est un terme de repos plus un terme par type de noyau, pondéré par la fraction du temps où CUPTI montre ce type en cours d’exécution. On l’ajuste sur des blocs où les types tournent un par un, puis on s’en sert pour répartir la puissance entre types.

La première sonde exécute des blocs de 2 s d’un seul type (un produit matriciel fp32, un produit matriciel fp16, et un passage limité par la mémoire sur un vecteur de 512 Mo) avec un taux d’activité de 25 % ou 50 %, dans un ordre mélangé. Sur dix exécutions, l’ajustement explique 89 à 97 % de la variance des échantillons de puissance (R² de 0,89 à 0,97), une fois la trace de puissance décalée de 0,25 à 0,5 s derrière les noyaux : même le champ instantané, que ces sondes lisent toutes les 10 ms, est en retard sur l’activité. Face au compteur d’énergie lu aux bornes de chaque bloc, le modèle reste à moins de 32 W pour chaque type et chaque taux d’activité (la moyenne de ses trois blocs), dans chaque exécution. Les coefficients varient avec la taille des noyaux et le taux d’activité, ils ne disent donc rien du genre « le fp16 coûte moins cher que le fp32 » ; ils ne valent que pour la charge sur laquelle ils ont été ajustés.

La seconde sonde est celle à laquelle le billet Kokkos ne pouvait pas répondre : deux streams, un produit matriciel fp32 sur l’un et un fp16 sur l’autre. Le modèle est ajusté sur les blocs où chaque stream tourne seul, puis doit prédire les blocs où les deux tournent.

Puissance moyenne de la carte sur les blocs où les deux streams tournent, mesurée avec le compteur d’énergie et prédite par le modèle ajusté sur les blocs à un seul stream. Moyennes sur 5 exécutions.
noyauxrecouvrementmesuréprédit
un matmul 8192×8192 à la fois par streamaucun265 W265 W
rafales de 40 petits matmuls 2048×2048environ un dixième du temps actif216 W228 W

Quand les gros noyaux remplissent le GPU chacun à leur tour, le modèle tombe juste en moyenne, à 1 W près sur les cinq exécutions, même si une exécution isolée peut s’en écarter de 13 W dans un sens ou dans l’autre. Quand les petits noyaux des deux streams se chevauchent, il surestime d’environ 13 W : deux noyaux qui se partagent le GPU consomment moins que ce que le modèle additionne à partir de chacun seul. Je ne m’appuierais pas trop sur ce chiffre, cependant. Dans les mêmes exécutions, le modèle surestime déjà de 3 à 5 W les blocs à un seul stream, et d’une exécution à l’autre la puissance mesurée des mêmes blocs varie d’environ 10 W : 13 W est un indice dans la bonne direction, pas une mesure de l’effet.

Ce que cela change pour l’outillage Kokkos

Le connecteur NVML que j’ai écrit à l’ORNL (#301) échantillonne nvmlDeviceGetPowerUsage sur un thread annexe et l’intègre sur chaque région. Sur cette carte, cette valeur ne change que deux fois par seconde et a environ une seconde de retard sur le GPU : une région de moins de quelques secondes reçoit la puissance de ce qui tournait avant elle. Lire le compteur d’énergie aux bornes des régions corrigerait le retard mais pas la résolution, et lu trop souvent, le compteur sous-compte. Ce qui tient, c’est ce qu’ont fait ces sondes : lire le compteur sur un minuteur lent, et répartir chaque fenêtre entre les noyaux avec les horodatages de CUPTI et un modèle ajusté, en acceptant que la répartition ne vaille pas mieux que le modèle quand les noyaux se chevauchent.

Rien de tout cela ne se transpose automatiquement à un H100 ou un A100 sous Linux, où NVML est connu pour se comporter autrement. L’intérêt de garder des sondes aussi petites, c’est de pouvoir les relancer là-bas avant de croire le moindre chiffre. La prochaine étape est justement de le faire sur le nœud où les exécutions du poster ont été faites.

Les scripts, les sorties brutes et le script qui redessine les figures sont sur GitHub : nvml-energy-probes. Le billet suivant applique ces règles à une vraie charge de travail.