Fuzzing pour la portabilité de performance et de précision dans les codes HPC

Fuzzing for performance and precision portability of HPC applications

• Auteur / Autrice : Aurélien Delval
• Direction : Pablo De oliveira castro
• Type : Projet de thèse
• Discipline(s) : Informatique
• Date : Inscription en doctorat le 01/02/2024
• Etablissement(s) : université Paris-Saclay
• Ecole(s) doctorale(s) : École doctorale Sciences et technologies de l'information et de la communication (Orsay, Essonne ; 2015-....)
• Partenaire(s) de recherche : Laboratoire : Laboratoire d'Informatique - Parallélisme Réseaux et Algorithmes Distribuée
• Partenaire(s) de recherche : référent : Université de Versailles-Saint-Quentin-en-Yvelines (1991-....)

Mots clés

Mots clés libres

Énergie

Précision numérique

Calcul Haute Performance

Fuzzing

Portabilité de performance

Optimisation

Numerical precision

Energy

Optimization

Performance Portability

Fuzzing

High Performance Computing

Résumé

De nos jours, l'écosystème du calcul à haute performance (HPC) est de plus en plus hétérogène. Les super-calculateurs utilisent une variété d'unités de traitement avec différentes micro-architectures, telles que Intel-64, AMD64, ARMv8 et incluent des accélérateurs spécialisés (GPU, TensorCores) pour les calculs spécifiques à un domaine. Ils mettent également en œuvre différents formats de virgule flottante, hiérarchies de mémoire, systèmes de stockage et interconnexions. Cette hétérogénéité rend difficile la maintenance et le développement de codes HPC. En effet, chaque système nécessite des optimisations spécifiques pour garantir le meilleur compromis entre performance, consommation d'énergie et précision. Cela crée une énorme surcharge pour les développeurs d'applications qui doivent optimiser et maintenir différentes branches de leur code pour chaque système cible. Cette thèse explorera la portabilité des optimisations pour la précision numérique, le temps de calcul et l'énergie. Au lieu de viser des optimisations spécifiques liées à une seule architecture, nous voulons concevoir des optimisations robustes qui fonctionnent bien sur différentes architectures. Les approches existantes évaluent la portabilité des performances en mesurant les métriques de portabilité à travers des matrices croisant différentes mini-applications et systèmes d'exécution. Ici, nous proposons plutôt cibler le problème de l'optimisation de la portabilité pour une application donnée. En particulier, nous voulons trouver des optimisations portables et robustes en exploitant les techniques de fuzzing. Nous souhaitons évaluer comment le fuzzing peut être étendu pour détecter les problèmes de portabilité de performance et de précision. L'idée clé de l'approche est de passer de l'analyse des entrées du programme à l'analyse des instructions. Lors de l'application du fuzzing pour la portabilité de l'optimisation, il faudra évaluer l'impact à la fois sur la performance et la précision. En effet, il est devenu essentiel de réduire la consommation d'énergie des codes de simulation et de trouver un bon compromis entre la précision du calcul et le coût. Afin de mesurer l'effet des perturbations sur la performance, nous proposons d'injecter des retards contrôlés à différents points de l'exécution du programme. En analysant l'effet des retards en termes de temps d'exécution et d'énergie, nous pouvons détecter les goulets d'étranglement d'énergie et de performance qui sont les plus sensibles à tout déséquilibre. Grace à cette mesure, nous pourrons chercher des versions robustes aux retards et aux changements d'architecture. L'injection de variations de performance dans un système a été explorée précédemment. Contrairement aux travaux précédents, nous proposons de chercher les versions de codes les moins sensibles aux perturbations en guidant la recherche par des métriques de couverture pour explorer efficacement les chemins du programme. Nous proposons également d'explorer les erreurs d'arrondi numérique à travers des techniques de fuzzing. Les approches précédentes utilisent des modèles stochastiques de virgule flottante pour détecter les bogues numériques et améliorer la portabilité des calculs numériques. Cependant, les approches stochastiques peuvent avoir des difficultés à trouver les pires chemins d'exécution car elles capturent un comportement moyen. Nous souhaitons évaluer si les approches de fuzzing permettent d'identifier les combinaisons d'arrondis correspondant au « pire-cas » pour l'erreur numérique. Ce doctorat sera l'occasion d'étudier l'applicabilité du fuzzing de programme pour la portabilité, en explorant les garanties et les fondements théoriques de ces approches dans le contexte HPC.

Nowadays, the High-Performance Computation (HPC) ecosystem is increasingly heterogeneous. Super-computers use a variety of processing units with different micro-architectures, such as Intel-64, AMD64, ARMv8 and include specialized accelerators (GPUs, TensorCores) for domain-specific computations. They also implement different floating-point formats, memory hierarchies, storage systems, and interconnects. This heterogeneity makes it difficult to maintain and develop HPC codes. Indeed, each system requires specific optimizations to ensure the best compromise between performance, energy consumption, and precision. This creates a huge overhead for application developers who must optimize and maintain different code branches for each target system. This thesis will explore how to achieve optimization portability for numerical precision, computation time, and energy. Instead of aiming for highly specific optimizations that are tied to a single architecture, we want to design robust optimizations that perform well in different architectures. Existing approaches evaluate performance portability by measuring portability metrics across matrices of different mini-applications and execution systems. Here, we would like instead to target the problem of optimizing portability for a given application. In particular, we want to find portable and robust optimizations by harnessing fuzzing techniques. We want to evaluate how fuzzing can be extended to detect performance and precision portability issues. The key insight in this approach is to move from fuzzing the program's inputs to fuzzing the application instructions. When applying fuzzing for optimization portability, targeting both performance and precision is crucial. Indeed it has become critical to reduce the power consumption of simulation codes and find a good compromise between computation accuracy and cost. To fuzz performance, we propose to inject controlled delays at different points in the program execution. By analyzing the effect of the delays in terms of execution time and energy, we can detect energy and performance bottlenecks that have no slack and are sensitive to any imbalance. This means we can find optimized versions that are robust to delays and which should be particularly robust to architecture change. Injecting performance variations in a system have been explored previously. Unlike previous works, our approach specifically optimizes for maximal slack and is guided by compiler coverage metrics to explore program paths efficiently. To fuzz precision, we propose to explore numerical rounding errors across program paths. Previous approaches use stochastic floating-point models to detect numerical bugs and improve the portability of numerical computations across different floating-point formats. Yet stochastic approaches might have difficulty finding worst-case execution paths since their exploration is randomized. Instead, we can focus on particular rounding combinations that trigger faulty behavior or accuracy loss by using coverage-guided fuzzing. This Ph.D. will be an opportunity to investigate the applicability of program fuzzing for portability, exploring the guarantees and theoretical underpinnings of such approaches in the HPC context.