Profiling and Tracing Tools for General-Purpose Computing on Graphics Processing Units (GPGPU)

Alors que les tâches de calcul nécessitent des ordinateurs de plus en plus puissants, ingénieurs et scientifiques explorent de nouvelles approches pour déveloper des systèmes de calcul efficaces à grande échelle. La plupart des programmes modernes de calcul haute performance font usage de systèmes hétérogènes hautement parallèles, mêlant des unités de calcul d’architectures variées. Les cartes graphiques ont évolué lors des dernières années pour se placer en véritable clef de voûte de nombreux de ces systèmes, permettant de fournir une puissance de calcul formidable à moindre coût. Le premier supercalculateur exaflopique, Frontier, dévoilé en 2022, en fait un usage considérable pour fournir le gros de sa puissance de calcul, composé de 37 888 cartes graphiques totalisant 1.325×108 opérations flottantes par seconde (FLOPS). Les cartes graphiques sont aussi devenues synonymes d’applications en apprentissage machine, dont les modèles, tendant à se complexifier, sont de plus en plus gourmands en puissance de calcul. Ces applications nécessitent d’utiliser le matériel disponible à sa pleine puissance. Les développeurs ont donc recours à une batterie d’outils de développement logiciel les aidant à évaluer la performance de leurs programmes. Le traçage logiciel est une approche d’instrumentation logicielle permettant de créer des outils qui enregistrent une suite d’évènements bas-niveau lors de l’exécution du programme instrumenté. Cette mesure se réalise avec une emphase sur la non-intrusivité des points de trace, permettant d’observer le programme le plus fidèlement possible. Cependant, bien que cette discipline soit bien étudiée sur processeurs standards, elle s’adapte difficilement sur cartes graphiques, du fait de leur haut niveau de parallélisme. Nous explorons dans cette thèse comment des approches de traçage peuvent être portées efficacement sur des codes de calcul s’exécutant sur carte graphique, tout en garantissant un surcoût d’instrumentation raisonnable. La première contribution de cette thèse propose une approche en deux phases permettant d’éviter les problématiques d’accès concurrent aux données. En décomposant le traçage en une première phase où le nombre d’évènements est compté, il est possible d’allouer des tampons de traçage pour chaque producteur d’évènements. La seconde phase, traçant le code de calcul sur les mêmes données en entrée, évite conséquemment le coût en performance d’introduire des sections critiques dans le code hautement parallèle. Cette méthode est implémentée en tant qu’extension de compilateur ainsi qu’une bibliothèque logicielle de gestion de données de traçage pendant l’exécution. Nous évaluons cette approche sur un banc d’essai de calcul haute performance, obtenant un surcoût vi de temps d’exécution normalisé médian de 1, 25× sur le temps de calcul sur carte graphique. Grâce à son surcoût d’exécution bas, cette méthode permet de développer des outils d’analyse précis pour cartes graphiques. Le second article présenté dans cette thèse explore des structures de données pour le traçage, adaptées aux cartes graphiques, afin d’éviter les deux exécutions présentées dans la première contribution. Cette particularité peut en effet être limitante dans certains cas, comme lorsque l’exécution du code n’est pas déterministe. Nous proposons une étude de la microarchitectue type des cartes graphiques et présentons des structures de données exploitant la proximité spatiale de la mémoire lors de l’exécution, en favorisant une bonne utilisation de la mémoire cache. Nous proposons deux types de structures : par tampon partagé ainsi que par allocation de sous-tampons de traçage. Ces structures sont évaluées sur un ensemble varié de codes de calcul. Enfin, nous établissons des cas d’utilisation types pour chaque approche, selon des propriétés intrinsèques du code GPU ainsi que l’objectif final visé par la démarche de traçage. La dernière contribution de cette thèse vise à améliorer la méthode d’instrumentation statique jusqu’alors présentée afin de réduire le nombre total de points de trace insérés dans le code. En observant la méthode de gestion de flot de contrôle vectoriel utilisé sur cartes graphiques, nous établissons une méthode permettant de calculer la valeur du masque d’exécution vectoriel à certains points, ne nécessitant donc pas d’instrumentation. Nous proposons un algrorithme d’analyse statique permettant d’identifier des chemins dans le graphe de flot de contrôle qui peuvent être ignorés lors de l’instrumentation. Nous montrons que cette analyse statique plus poussée résulte en une réduction importante de la taille des traces ainsi que du surcoût d’exécution lié au traçage. L’ensemble de ces travaux permet de tracer, de différente manières, l’exécution de programmes sur GPUs afin de maximiser l’efficacité pour différents cas d’usage. Il devient alors possible d’obtenir des mesures précises du comportement des programmes, ce qui n’était pas envisageable précédemment, les approches existantes ayant un surcoût d’exécution trop élevé qui perturbe considérablement les mesures. Ces traces détaillées permettent une analyse de performance poussée et précise de programmes accélérés sur GPU.