Compilation and optimizations for variable precision floating-Point arithmetic : from language and libraries to code generation

Les unités de calcul à virgule flottante (FP) prennent en charge un sous-ensemble de formats définis par la norme IEEE 754, ainsi que quelques formats qui leur sont spécifiques (le format de 80 bits sur de l’architecture x86, et le format 128 bit propriétaire des PowerPC). De fait, les langages et les compilateurs optimisants utilisés en calcul intensif sont limités par les formats supportés sur les machines cibles. Cependant, la recherche de l’efficacité et de la stabilité des applications a conduit les numériciens à explorer d’autres tailles pour les exposants et les parties fractionnaires afin de trouver un bon équilibre entre la précision des résultats, le temps d’exécution et l’énergie consommée. C’est le cas pour les calculs numériques qui font appel à des solveurs itératifs dont l’erreur résiduelle est une fonction des données d’entrée, ou ceux pour lesquels une précision adaptable dynamiquement peut accélérer la convergence. Les numériciens doivent recourir à des conversions explicites et prévoir plusieurs versions du code, ce qui entraîne un accroissement de la taille de ce dernier au détriment de sa lisibilité Peu d’attention a été accordée au support d’autre formats flottants dans les langages et à leur compilation, ainsi qu’à leurs conséquences sur le processus d’analyse numérique. Le calcul en précision variable est un paradigme récent qui propose de faire varier les formats à l’exécution et d’en analyser les effets. Les travaux que nous présentons visent à surmonter les limites actuelles des langages et de leur compilation en y ajoutant le support aux formats à précision variable, et en abordant certains des problèmes que ces formats font apparaître à la jonction de la compilation et de l’arithmétique à précision variable. Pour cela nous proposons une extension du système de types du langage C permettant de représenter de manière générique les formats flottants et leurs opérations, aussi bien en précision statique que dynamique. Nous avons mis en œuvre un flot de compilation qui implémente ce système de type jusqu’à la génération de code vers des jeux d’instructions ou des bibliothèques supportant de tels formats. Notre solution basée sur LLVM a démontré son efficacité en tirant parti des puissantes optimisations de LLVM, notamment l’optimisation de nids de boucles par Polly. Nous proposons un support pour deux générateurs de code : un premier pour le jeu d’instruction d’un coprocesseur arithmétique à précision variable, et un deuxième ciblant la bibliothèque MPFR de virgule flottante en multi précision. Ce support démontre les avantages de productivité de notre modèle de programmation intuitif et sa capacité à tirer parti d’une chaîne de compilation existante. Les expérimentations réalisées sur deux suites de référence en calcul à haute performance ont permis d’obtenir de fortes accélérations aussi bien pour nos cibles logicielles que matérielles. Nous présentons également des résultats intéressants sur l’utilisation de la précision variable pour des noyaux d’algèbre linéaire.Floating-Point (FP) units in processors are generally limited to supporting a subset of formats defined by the IEEE 754 standard, along with a few target-specific ones (X86 with an 80-bit FP format, and PowerPC performing 128-bit FP arithmetic). As a result, high-efficiency languages and optimizing compilers for high-performance computing are also limited by the FP types supported by these units. However, the pursuit of efficiency and stability on applications has led researchers to investigate a finer control of exponent and fraction bits for finding the right balance between accurate results and execution time and/or energy consumed. For example, numerical computations often involve iterative solvers where the residual error is a function of the input data, or where dynamically adaptive precision can accelerate convergence. Numerical analysts have to resort to explicit conversions and multi-versioning, resulting in code bloat and making the intent of the program even less clear. Little attention in languages and compilers has been given to formats that disrupt the traditional FP arithmetics with runtime capabilities and allow the exploration of multiple configurations, a paradigm recently referred to as variable precision computing. This thesis proposes to overcome the limiting language and compiler support for traditional FP formats with novel FP arithmetic with runtime capabilities, showing the intersection between compiler technology and variable precision arithmetic. We present an extension of the C type system that can represent generic FP operations and formats, supporting both static precision and dynamically variable precision. We design and implement a compilation flow bridging the abstraction gap between this type system and low-level FP instructions or software libraries. The effectiveness of our solution is demonstrated through an LLVM-based implementation, leveraging aggressive optimizations in LLVM including the Polly loop nest optimizer. We provide support for two backend code generators: one for the ISA of a variable precision FP arithmetic coprocessor, and one for the MPFR multi-precision floating-point library. We demonstrate the productivity benefits of our intuitive programming model and its ability to leverage an existing compiler framework. Experiments on two high-performance benchmark suites yield strong speedups for both our software and hardware targets. We also show interesting insights on the use of variable precision computing in linear algebra kernels