85.30 GFLOPS Single-Core FP32 Matrix Multiplication on AMD Zen 3: A Systematic Study of Cache Blocking, Register Blocking, FMA Chaining, and On-the-Fly Packing
Cet article présente une étude d'optimisation systématique sur la microarchitecture AMD Zen 3 qui atteint 85,30 GFLOPS en multiplication de matrices FP32 monocœur en évaluant 28 configurations distinctes de blocage de cache/registre, de chaînage FMA et de mise en mémoire tampon instantanée (on-the-fly packing), identifiant finalement un design champion qui atteint 63,5 % de la performance de crête théorique tout en introduisant un modèle prédictif pour des optimisations futures.
Article original sous licence CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète
Imaginez que vous essayez de déplacer un énorme tas de sable (des données) d'un côté à l'autre d'un immense entrepôt, mais que vous devez le faire à l'aide d'un minuscule bras robotique ultra-rapide (le processeur). Le but est de mélanger le sable avec une formule spéciale (la multiplication de matrices) aussi rapidement que possible. Ce document est le journal de bord détaillé d'un chercheur, Lucas, qui tente de faire bouger ce bras robotique le plus vite que l'homme puisse l'imaginer sur un type de puce informatique spécifique appelé AMD Zen 3.
Le grand objectif : Qu'est-ce qu'une vitesse rapide ?
Le bras robotique a une vitesse de pointe théorique de 134,4 GFLOPS (cela signifie 134,4 milliards d'opérations mathématiques par seconde). Considérez cela comme la limite de vitesse sur une autoroute. Lucas voulait voir à quel point il pouvait se rapprocher de cette limite de vitesse sans construire une nouvelle voiture, simplement en réglant le moteur.
Après avoir testé 28 stratégies de conduite différentes, il a trouvé une configuration "championne" (appelée MX24) qui a atteint 85,30 GFLOPS. C'est environ 63,5 % de la vitesse maximale. Ce n'est pas un 100 % parfait, mais c'est un bond énorme par rapport à la ligne de départ, qui était une méthode lente et maladroite tournant à seulement 1,51 GFLOPS. En fait, sa meilleure méthode était 57 fois plus rapide que la version de base non optimisée.
La stratégie gagnante : La danse du "4-Row, Chain-4"
Pour obtenir cette vitesse, Lucas a dû déterminer comment organiser le sable et les mouvements du robot. Voici les mouvements clés qu'il a découverts :
1. L'astuce du rangement "à la volée"
Imaginez que le sable est stocké dans une grille où vous devez marcher en diagonale pour saisir le grain suivant. C'est lent et fatigant. Lucas a découvert que copier un petit morceau de sable en une ligne droite et nette juste avant que le robot n'en ait besoin (appelé packing à la volée ou on-the-fly packing) était le mouvement magique. C'est comme avoir un assistant qui court devant pour empiler les briques en une rangée parfaite afin que le robot puisse simplement les saisir les unes après les autres sans trébucher. Cela battait l'ancienne méthode consistant à simplement les saisir telles qu'elles étaient, et c'était même meilleur que de réorganiser l'entrepôt entier au préalable.
2. L'empilement "4-Row"
Le robot a un nombre limité de mains (registres) pour tenir le sable pendant qu'il travaille. Lucas a essayé de tenir 2 rangées de sable, puis 4, puis 8.
- 2 rangées : Trop peu. Le robot devait s'arrêter et aller chercher du nouveau sable trop souvent.
- 8 rangées : Trop ! Les mains du robot étaient si pleines qu'il devait laisser tomber du sable sur le sol (la mémoire) et le ramasser constamment. C'était un désastre.
- 4 rangées : Le point d'équilibre idéal. Même si le robot devait laisser tomber quelques grains sur le sol et les ramasser à nouveau (un processus appelé "spilling" ou déversement), le travail supplémentaire en valait la peine car il pouvait traiter plus de sable à la fois. Ce seul changement a rendu le robot 59 % plus rapide que la méthode à 2 rangées.
3. Le rythme "Chain-4"
Le bras du robot prend 4 secondes (cycles) pour terminer un seul mouvement mathématique avant de pouvoir commencer le suivant sur le même morceau de sable. Si le robot faisait un seul mouvement et attendait, il resterait inactif pendant 3 secondes.
Lucas a découvert que si le robot tenait 4 piles de sable différentes dans ses mains et travaillait sur elles en boucle (Chain-4), il pouvait maintenir le bras en mouvement constant. Pendant qu'une pile "cuisait", il travaillait sur les autres. Cela correspondait parfaitement au temps de cuisson de 4 secondes du robot, maintenant le moteur à plein régime.
Ce qui n'a pas fonctionné (La liste des "À ne pas faire")
Parfois, ce que vous pensez qui devrait fonctionner peut en réalité aggraver les choses. Lucas a testé quelques idées populaires et a constaté qu'elles étaient terribles pour ce robot spécifique :
- L'erreur du "Pre-fetch" : Les gens disent souvent aux robots de "regarder devant eux" et de saisir le grain de sable suivant avant d'en avoir besoin. Lucas a essayé cela, mais les yeux intégrés du robot étaient déjà si bons pour reconnaître le motif que les commandes supplémentaires de "regard en avant" ne faisaient que gêner. Cela a ralenti le robot d'environ 8 %.
- Le déversement "Non-Temporel" : Il existe une astuce qui consiste à dire au robot de déverser le sable directement sur le sol sans le mettre dans un bac d'abord. Cela fonctionne très bien si vous ne faites que jeter des déchets. Mais ici, le robot doit mélanger le sable, ce qui signifie qu'il doit le ramasser à nouveau. Le déverser directement a fait trébucher le robot sur ses propres pieds, faisant chuter sa vitesse à un dérisoire 1,24 GFLOPS.
- La surcharge "8-Row" : Comme mentionné, essayer de tenir 8 rangées de sable a provoqué tellement de chutes de sable que le robot passait plus de temps à le ramasser qu'à le déplacer.
Sommes-nous certains ?
Le papier est très confiant dans ces chiffres car ils ont été mesurés, et non simplement devinés. Lucas a exécuté le code 15 fois pour chaque stratégie, a écarté les exécutions les plus rapides et les plus lentes (pour éviter les bugs informatiques étranges) et a calculé la moyenne du reste. Il a également vérifié ses calculs par rapport à une version simple et lente pour s'assurer que la version rapide n'avait pas triché.
Il a même construit un modèle de "pré-filtre" mathématique — une sorte de boule de cristal — pour prédire la vitesse d'une stratégie avant même de l'exécuter réellement. Cette boule de cristal était assez bonne, se situant à moins de 11,3 % de la vitesse réelle pour la plupart des stratégies. Elle avait tendance à être un peu conservatrice, prédisant que la meilleure stratégie serait de 78,1 GFLOPS, alors qu'en réalité, elle a atteint 85,30 GFLOPS.
La conclusion
Ce document prouve que vous n'avez pas besoin d'être un magicien écrivant du code en "langage assembleur" (la langue maternelle du robot) pour obtenir une vitesse incroyable. En utilisant des outils standards (les intrinsèques C++) et en ajustant soigneusement les "pas de danse" (blocage, chaînage et rangement), vous pouvez amener votre ordinateur à fonctionner à 63,5 % de son maximum théorique.
La leçon principale ? Ne devinez pas. Ce qui fonctionne pour un type de robot (ou de puce informatique) peut en casser un autre. Lucas a testé 28 combinaisons différentes pour trouver celle qui fonctionnait, montant ainsi que parfois, les astuces "évidentes" (comme regarder devant soi ou déverser directement) sont en fait les mauvais mouvements.
Noyé(e) sous les articles dans votre domaine ?
Recevez des digests quotidiens des articles les plus récents correspondant à vos mots-clés de recherche — avec des résumés techniques, dans votre langue.