Compilation pour machines à mémoire répartie : une approche multipasse

Compilation for distributed memory machines : a multipass approach

• Auteur / Autrice : Nelson Lossing
• Direction : François Irigoin, Corinne Ancourt
• Type : Thèse de doctorat
• Discipline(s) : Informatique temps réel, robotique et automatique
• Date : Soutenance le 03/04/2017
• Etablissement(s) : Paris Sciences et Lettres (ComUE)
• Ecole(s) doctorale(s) : École doctorale Sciences des métiers de l'ingénieur (Paris)
• Partenaire(s) de recherche : Laboratoire : Centre de recherche en informatique (Fontainebleau, Seine et Marne)
• Partenaire(s) de recherche : établissement de préparation de la thèse : École nationale supérieure des mines (Paris ; 1783-....)
• Jury : Président / Présidente : Christine Eisenbeis
• Jury : Examinateurs / Examinatrices : François Irigoin, Corinne Ancourt, Elisabeth Brunet, Antoniu Pop
• Jury : Rapporteurs / Rapporteuses : Henri-Pierre Charles, Frédéric Desprez

Mots clés

Mots clés contrôlés

Mémoire partagée répartie

Mots clés libres

Langages parallèles

Compilation

Mémoire distribuée

Architecture parallèle distribuée

Parallélisation de tâche

Génération automatique de code

Vérification de code

Parallel languages

Compilation

Distributed memory

Distribued parallel architecture

Task parallelisation

Automatic code generation

Code verification

Résumé

Les grilles de calculs sont des architectures distribuées couramment utilisées pour l'exécution de programmes scientifiques ou de simulation. Les programmeurs doivent ainsi acquérir de nouvelles compétences pour pouvoir tirer partie au mieux de toutes les ressources offertes. Ils doivent apprendre à écrire un code parallèle, et, éventuellement, à gérer une mémoire distribuée.L'ambition de cette thèse est de proposer une chaîne de compilation permettant de générer automatiquement un code parallèle distribué en tâches à partir d'un code séquentiel. Pour cela, le compilateur source-à-source PIPS est utilisé. Notre approche a deux atouts majeurs : 1) une succession de transformations simples et modulaires est appliquée, permettant à l'utilisateur de comprendre les différentes transformations appliquées, de les modifier, de les réutiliser dans d'autres contextes, et d'en ajouter de nouvelles; 2) une preuve de correction de chacune des transformations est donnée, permettant de garantir que le code généré est équivalent au code initial.Cette génération automatique de code parallèle distribué de tâches offre également une interface de programmation simple pour les utilisateurs. Une version parallèle du code est automatiquement générée à partir d'un code séquentiel annoté.Les expériences effectuées sur deux machines parallèles, sur des noyaux de Polybench, montrent une accélération moyenne linéaire voire super-linéaire sur des exemples de petites tailles et une accélération moyenne égale à la moitié du nombre de processus sur des exemples de grandes tailles.

Scientific and simulation programs often use clusters for their execution. Programmers need new programming skills to fully take advantage of all the available resources. They have to learn how to write parallel codes, and how to manage the potentially distributed memory.This thesis aims at generating automatically a distributed parallel code for task parallelisation from a sequential code. A source-to-source compiler, PIPS, is used to achieve this goal. Our approach has two main advantages: 1) a chain of simple and modular transformations to apply, thus visible and intelligible by the users, editable and reusable, and that make new optimisations possible; 2) a proof of correctness of the parallelisation process is made, allowing to insure that the generated code is correct and has the same result as the sequential one.This automatic generation of distributed-task program for distributed-memory machines provide a simple programming interface for the users to write a task oriented code. A parallel code can thus automatically be generated with our compilation process.The experimental results obtained on two parallel machines, using Polybench kernels, show a linear to super-linear average speedup on small data sizes. For large ones, average speedup is equal to half the number of processes.