Code specialization strategies for high performance architectures

Many applications are unable to obtain the peak performance offered by high performance architectures such as Itanium or Pentium-IV. This fact makes the code optimizations to be of utmost importance. Code specialization, which provides to the compilers, necessary information regarding important parameters in the code, is considered to be one of the most effective optimizations.Static specialization of code results in large code size, also referred to as, code explosion. Such large size of code results in cache misses and branch overhead, and also minimizes the effect of other optimizations. All these drawbacks deteriorate the performance of the application and necessitate the code to be specialized dynamically. The specialization of code is therefore performed by dynamic compilers and/or specializers by generating code at runtime, i.e. during execution of the program. The runtime specialization is not always beneficial since the runtime activities incur a large overhead during execution. This overhead can only be amortized by multiple invocations of the same code. Aimed at improving the performance of the applications, this thesis provides different strategies for specialization of code. By specializing code through static, dynamic and iterative compilation, we target the issues of code explosion and runtime overhead. Our Hybrid Specialization approach proceeds by specializing code and finding equivalent code versions. Instead of keeping all versions, any of these versions can be used as a template whose instructions are modified at runtime to adapt it to other versions. The performance is improved since the code is specialized at static compile time. The runtime specialization is therefore limited to modifying a small number of instructions. Different variants of these approaches address the issues of selection of variables for specialization, minimizing the number of compilations and reducing the frequency of runtime specialization.Our Iterative Specialization approach is able to optimize regular code by obtaining different optimization classes of some code which is specialized at static compile time. The code is iteratively transformed to benefit from these optimization classes and evaluated in order to obtain the best version.These approaches are portable and tested on high performance architectures like IA-64 and Pentium-IV using different versions of \textit{icc} and \textit{gcc} compilers. Using hybrid specialization and iterative specialization approaches, we are able to obtain a significant improvement in many complex benchmarks including SPEC, FFTW and ATLAS.De nombreuses applications sont incapables d'utiliser les performances crêtes offertes par des architectures modernes comme l'Itanium et Pentium-IV. Cela rend critique les optimisations de code réalisée par les compilateurs. Parmis toutes les optimisations réalisées par les compilateurs, la spécialisation de code, qui fournit aux compilateurs les valeurs des paramètres importants dans le code, est très efficace. La spécialisation statique a comme défault de produire une grande taille du code, appelée, l'explosion du code. Cette grande taille implique des défaults de caches et des coûts de branchements. Elle même impose des contraintes sur d'autres optimisations. Tous ces effets rendent nécessaire de spécialiser le code dynamiquement. La spécialisation de code est donc effectué par lescompilateurs/specialiseurs dynamiques, qui générent le code àl'exécution. Ces approches ne sont pas toujours bénéfique puisque l'exécution doit subir un grand surcoût de géneration à l'exécution qui peut détériorer la performance. De plus, afin d'être amorti, ce coût exige plusieurs invocations du même code.Visant à améliorer les performances des applications complexes, cettethèse propose différentes stratégies pour la spécialisation du code. En utilisant la compilation statique, dynamique et itérative, nous ciblons les problèmes d'explosion de la taille du code et le surcoût en temps induit par la génération du code à l'exécution. Notre "Spécialisation Hybride" génère des versions équivalentes du code après l'avoir specialisé statiquement. Au lieu de conserver toutes les versions, l'une de ces versions peut être utilisée comme un template dont les instructions sont modifiées pendant exécution afin d'être adaptée à d'autres versions. La performance est améliorée puisque le code est spécialisé au moment de la compilation statique. La spécialisation dynamique est donc limitée à la modification d'un petit nombre d'instructions.Différentes variantes de ces approches peuvent améliorer laspécialisation en choisissant des variables adéquates, en diminuant le nombre de compilations et en réduisant la fréquence de laspécialisation dynamique. Notre approche "Spécialisation Itérative" est en mesure d'optimiser les codes régulier en obtenant plusieurs classes optimales du code spécialisé au moment de la compilation statique. En suite, une transformation itérative est appliquée sur le code afin de bénéficier des classes optimales générées et obtenir la meilleure version. Les expérimentations ont été effectuées sur des architectures IA-64 et Pentium- IV, en utilisant les compilateurs gcc et icc. Les approches proposées (Spécialisation Hybride et Itérative), nous permettent d'obtenir une amélioration significative pour plusieurs benchmarks, y compris ceux de SPEC, FFTW et ATLAS.VERSAILLES-BU Sciences et IUT (786462101) / SudocSudocFranceF