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.

Abstract

As computing workloads require endlessly increasing computing power, engineers and scientists have explored new ways to provide efficient computing systems at a large scale. Most modern High Performance Computing (HPC) codes leverage massively parallel heterogeneous systems, composed of many different kinds of processor architectures. Graphics Processing Units (GPUs) have evolved in the past decades to become a key element of these systems, as they provide easily accessible raw computing power at an affordable price. The first exascale supercomputer, Frontier, revealed in 2022, relies largely on its 37,888 GPUs to achieve its 1.325 × 108 Floating Point Operations per Second (FLOPS). GPUs have also become ubiquitous in Machine Learning applications, which have become more and more power-hungry as the models become increasingly complex. As computationally intensive applications require making the most of the hardware, HPC programmers rely extensively on software tooling to evaluate the performance of their code. Software Tracing is a tooling approach that consists in recording low-level events at run time when certain conditions are met, with an emphasis on minimizing instrumentation noise. However, while efficient tracing has been studied in great depth for CPUs, the sheer scale and massive parallelism featured in GPUs does not allow these well-studied methods to be easily transposed to GPUs. In this thesis, we explore how efficient tracing can be adapted to GPU compute kernels. The first contribution of this thesis lays the foundations for efficient, in-kernel tracing with a focus on lower overhead than comparable approaches on GPUs. We propose an instrumentation method that decomposes the kernel tracing in two phases. We first count the total number of events and subsequently allocate buffers of the correct size, alleviating the need for interaction between event producers. The compute kernel is then run a second time with tracing instrumentation on the same input arguments, thus recording the events at a lower runtime cost than if critical sections were needed to serialize interactins. This novel method is implemented as a compiler plugin and runtime library, and evaluated against a scientific computing benchmark. With a median normalized kernel runtime overhead of 1.26×, the approach presented in this work allows tool developers to gather precise traces from GPU compute kernels. The second article presented in this thesis explores data structures for tracing that alleviate the need for two kernel executions, as this can prove limiting for some kernels. We study GPU microarchitectures and present data structures that leverage memory locality on the viii device. We explore how shared-buffer and allocation-based approaches perform on a variety of compute kernels. In light of these results, we identify specific tracing use cases, depending on both intrinsic kernel features and how well the different methods perform in varied scenarios. The final contribution of this thesis extends the compiler instrumentation method used in the first two studies to reduce the number of tracepoints inserted in the code. Relying on stackbased vector control flow management mechanisms used on GPUs, we show that observing which paths not taken by some threads can help later deduce the ones that were indeed taken. This means some tracing information information can be deduced post-mortem, without the need to instrument these paths. We propose a static analysis algorithm that identifies in topological order which paths in the Control Flow Graph (CFG) do not require tracepoints. We show that the reduced number of tracepoints in the code translates to an important reduction in total trace size, as well as a reduction in run-time overhead. The contributions presented in this thesis allow to trace, in different manners, the execution of programs GPUs to minimize the impact for many use cases. It is then possible to obtain precise measurements of how the program behaves on the device, in a way that was not possible before, as existing methods presented a much higher performance overhead which interferes considerably with the program. The resulting traces allow tools to present detailed and precise performance analyses for GPU-accelerated code.