OptiTrust : vers des codes informatiques optimisés et sans bugs

Il y a ceux qui savent optimiser les codes pour les rendre plus rapides, et ceux qui savent les vérifier pour détecter et éliminer les bugs. Et puis il y a OptiTrust, l'action exploratoire soutenue par Inria et dirigée par Arthur Charguéraud... qui projette de faire les deux à la fois. Une ambition qui a commencé à se concrétiser il y a trois ans, lors de travaux menés conjointement par les équipes-projets Camus et Tonus d'Inria Nancy Grand-Est dans le cadre de la thèse d'un étudiant, Yann Barsamian. Celle-ci visait à optimiser un code pour la simulation du comportement des particules dans des plasmas (le même type de phénomènes que ce qui se passe dans le Soleil). « Pour que la simulation soit la plus précise et la plus réaliste possible, il faut pouvoir prendre en compte un nombre maximum de particules, précise Arthur Charguéraud. Et pour que les performances restent acceptables, il faut utiliser toutes les possibilités offertes par le parallélisme. »

En effet, les particules sont prises en charge par plusieurs serveurs connectés entre eux, qui eux-mêmes contiennent chacun jusqu'à 64 cœurs de calculs, qui eux-mêmes intègrent des instructions parallèles (appelées « instructions SIMD » pour Single Instruction Multiple Data), chacune capable d'effectuer 16 opérations arithmétiques d'un coup. « En mettant à profit les capacités de chacun de ces niveaux, avec 200 serveurs par exemple, on peut simuler le comportement de 1 000 milliards de particules », s'enthousiasme le chercheur.

Un code qui réécrit les codes

Encore faut-il mettre au point un code capable d'exploiter au mieux cette puissance. « Yann Barsamian avait réussi à écrire un code qui donnait de bonnes performances, mais il avait dû pour cela essayer de très nombreuses options d'optimisation », poursuit Arthur Charguéraud. Or, écrire manuellement des centaines de lignes de code pour chacune de ces options est extrêmement chronophage. Sans compter que chaque modification manuelle du code augmente les risques d'introduire une erreur ! En outre, lorsque les serveurs utilisés changent, les optimisations les plus efficaces précédemment peuvent ne plus l'être. Et certaines optimisations doivent même être "défaites". D'où l'idée d'une solution qui puisse créer des codes efficaces et performants, portables et dénués de bugs.

Pour atteindre cet idéal, Arthur Charguéraud a eu l'idée de "faire faire le travail par l’ordinateur", en écrivant un code qui ferait le travail d’optimisation à sa place ! C'est ainsi qu'est née l'action exploratoire OptiTrust. « C'est un pari risqué car l’approche sous-jacente, appelée "transformation de code" divise les chercheurs du domaine informatique : certains ne sont pas convaincus que l'on puisse obtenir des codes performants de la sorte, tandis que d'autres exploitent cette piste mais en s'appuyant sur des langages de programmation très spécifiques d’un domaine d'application, expose le porteur d'OptiTrust. Nous avons, quant à nous, décidé d'utiliser des transformations de code mais avec un langage généraliste, très largement utilisé (le langage C), ce qui nous permet d'optimiser des programmes très variés. »

Un code... et l'intuition humaine

Concrètement, il s'agit de mettre au point un outil qui se charge de modifier le code à la place de l'humain mais en suivant les instructions de celui-ci.
Le programmeur écrit d'abord son code initial, sans se soucier des performances, en spécifiant seulement qu'il cherche par exemple à simuler le déplacement de particules dans le plasma. Puis il conçoit un second code, appelé "script", qui explique comment il souhaite modifier le code initial pour le rendre plus performant. Chaque transformation est choisie dans un catalogue, programmé une fois pour toutes. L'enchaînement de ces transformations produit le code final optimisé.

« Ce système résout tous les problèmes rencontrés jusqu'ici : il permet de tester très rapidement des dizaines d'enchaînements d'optimisations, estime Arthur Charguéraud. En outre, si le script est déplacé sur une autre machine, il peut recommencer l'opération et trouver de nouveau la meilleure optimisation. Et de même, si le programmeur modifie le code initial, il suffira de désactiver les optimisations qui ne s'appliqueront plus tandis que d'autres transformations pourront continuer à s'appliquer. Enfin, comme le programmeur ne modifie pas son code à la main, l'écriture du code sera beaucoup plus rapide et il y aura beaucoup moins de bugs. »

Surmonter les obstacles de l'optimisation et de la vérification

Cela, c'est pour la théorie... mais la mise en œuvre est compliquée. D'abord parce qu'il faut réussir à indiquer au script la ligne de code sur laquelle il doit intervenir... sur un code qui aura déjà été modifié par des transformations antérieures. « Pour contourner cette difficulté, il faut trouver un moyen de se repérer dans le code, et pour cela nous nous appuierons sur une notion de "chemin", révèle Arthur Charguéraud. L'idée d'un chemin est d'identifier dans le code des points de passage qui seront préservés par les premières transformations et qui serviront de repères pour indiquer à quelles lignes appliquer les transformations suivantes. »

Le deuxième obstacle majeur est d’assurer qu’il n’y ait pas de bugs dans le code réalisant les transformations,  : ce code est  conçu pour modifier un autre code, or dans ce type d'outil, les risques de bugs sont nombreux. « La preuve : dans les compilateurs utilisés par les langages de programmation, qui sont également des codes qui transforment d’autres codes, on trouve des bugs tous les jours. Alors que ces compilateurs existent depuis des dizaines d'années ! », relève le chercheur. La solution ? La preuve formelle : des outils qui permettent de prouver mathématiquement que, quel que soit le code fourni, la transformation va toujours produire un code équivalent, à savoir qui calcule la même chose (mais plus rapidement).

Des applications dans des domaines variés

Fort de ces idées, Arthur Charguéraud a proposé son action exploratoire en mars 2019... et a mis moins de deux mois à obtenir le feu vert d'Inria qui lui accorde un financement de postdoc sur deux ans, ainsi qu'un budget pour des missions en France et à l'étranger et du matériel.

Le projet, démarré en octobre 2019, a déjà permis d'avancer sur la manipulation des chemins et s'attaque à présent au catalogue de transformations. L'objectif : emmener l'outil jusqu'à l'étude de cas, c'est-à-dire la comparaison entre le code produit par les transformations et celui conçu par le doctorant de l'équipe Camus Yann Barsamian. En espérant qu'avec quelques dizaines de lignes de code de départ et quelques dizaines d'instructions de transformations, il soit possible de générer un code au moins aussi performant que les milliers de lignes de code écrites à la main. « Pour ce cas précis, je suis convaincu que c'est faisable, annonce le chercheur. Une fois notre outil au point, il s'agira d'évaluer l'approche sur d'autres codes de simulation numérique sur lesquels travaille l'équipe-projet Tonus. Et, si cela fonctionne, nous verrons plus largement si l'outil permet d'optimiser des programmes venant d'autres domaines, pour lesquels la performance est également un besoin critique. Il pourrait à terme faciliter les travaux de partenaires, industriels ou académiques, et des développeurs spécialisés en calcul haute performance. »