Département informatique Implémentation d`algorithmes pair à pair

Département informatique
Diplôme préparé : DUT informatique
Numéro de jury : 4
Implémentation d’algorithmes pair à pair et amélioration
des interfaces utilisateur sur le simulateur SimGrid
Samuel LEPETIT
Tuteur enseignant
Chantal ESCUDIÉ
Bât.407
Université Paris-Sud
91400 Orsay
France
Maître d’apprentissage
Martin QUINSON
Equipe AlGorille, Batiment B
LORIA – Campus Scientifique
BP 239 – 54506
Vandoeuvre-lès-Nancy Cedex
Année universitaire 2011-2012
16 Avril 2012 au 6 juillet 2012
Soutenance du 18 juin 2012
1
TABLE DES MATIÈRES
Table des matières
1 Institution d’accueil 6
1.1 LeLORIA........................................... 6
1.2 LéquipeAlGorille ...................................... 6
2 Contexte et objectifs du stage 7
2.1 Applicationsdistribuées ................................... 7
2.2 SimGrid............................................ 7
2.3 linterfaceMSG........................................ 8
2.3.1 Fichiers de plate-forme et de déploiement . . . . . . . . . . . . . . . . . . . . . 8
2.3.2 Lesprocessus..................................... 8
2.3.3 Communication entre les processus . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.4 Objectifsdustage ...................................... 9
3 Implémentation d’algorithmes pair à pair 10
3.1 Lepairàpair......................................... 10
3.2 ChordJava .......................................... 11
3.3 Kademlia ........................................... 13
3.3.1 Messages ....................................... 13
3.3.2 Tablesderoutage................................... 13
3.3.3 Protocole pour rejoindre le réseau . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.3.4 Détails sur l’implémentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.4 Bittorrent........................................... 14
3.4.1 Le protocole entre pairs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.4.2 Algorithme de choix de la pièce à télécharger . . . . . . . . . . . . . . . . . . . 16
3.4.3 Protocole de choix des pairs actifs . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.4.4 Détails sur l’implémentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4 Amélioration des interfaces utilisateur 18
4.1 Amélioration de l’interface Java pure . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.1.1 Refactorisation du code de SimGrid Java . . . . . . . . . . . . . . . . . . . . . 18
4.1.2 Implémentation des communications asynchrones . . . . . . . . . . . . . . . . . 19
4.1.3 Changement de la manière dont les processus sont lancés . . . . . . . . . . . . 19
4.1.4 Mise en cache des éléments Java . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.1.5 Ajout d’une interface pour la génération de nombres pseudo-aléatoires . . . . . 21
4.2 Création d’une interface java à très hautes performances . . . . . . . . . . . . . . . . . 21
5 Évaluation expérimentale 23
5.1 CachedesélémentsJava................................... 23
5.2 Lancement des processus coté C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
5.3 Interface haute performance utilisant les Coroutines . . . . . . . . . . . . . . . . . . . 25
5.4 Expériences sur l’algorithme Chord . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
5.5 Amélioration globale des performances . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
5.6 Complexité en terme de quantité de code . . . . . . . . . . . . . . . . . . . . . . . . . 27
2
RÉSUMÉ
Résumé
Ce stage de fin de DUT Informatique s’est déroulé au LORIA[4] à Nancy, dans l’équipe AlGorille,
sous la direction de Martin QUINSON, du 15 avril au 6 juillet 2012.
J’ai eu l’occasion durant ce stage de travailler sur le projet SimGrid, qui est une boite à outils
permettant de concevoir des simulateurs d’applications distribuées dans des environnements hétéro-
gènes, permettant notamment de faire des simulations sur des algorithmes pair à pair. SimGrid, bien
que programmé en C, possède également des interfaces permettant de l’utiliser dans un autre langage,
dont une interface Java.
Le pair à pair est un système d’organisation décentralisé d’un réseau opposé au schéma client-
serveur classique, où chaque ordinateur dans le réseau est à la fois un client et un serveur, qui a
diverses applications. Différents algorithmes permettant d’organiser les réseaux de nœuds ont ainsi été
proposés.
Les deux objectifs principaux de ce stage étaient l’implémentation d’algorithmes pair à pair afin
de les tester sur SimGrid et l’amélioration de l’interface Java existante.
Les algorithmes Kademlia et Bittorrent ont ainsi pu être implémentés sur la plateforme SimGrid,
en C et en Java, afin de proposer des exemples aux utilisateurs mais également pour comparer les
performances entre les interfaces C et Java, et enfin pour dépister des bogues dans SimGrid lui même.
Une implémentation de l’algorithme Chord en Java a également été réalisée.
Également, des travaux ont été réalisés afin d’améliorer les performances de l’interface Java de
SimGrid et de la pourvoir des mêmes fonctionnalités que l’interface C .
Des évaluations expérimentales sur Grid’5000[2] ont pu être réalisées, permettant de prouver ex-
périmentalement le gain de performances de chacune des modifications apportées à l’interface Java,
et montrant un gain de performance d’environ 50%. Ces expériences ont également pu montrer que
l’interface expérimentale développée permet de diviser le temps d’exécution des simulations par 5
environ.
3
RÉSUMÉ
Remerciements
Je tiens à remercier Martin QUINSON, mon maitre de stage pour m’avoir accueilli et encadré
durant tout ce stage, mais aussi pour m’avoir permis d’acquérir de nouvelles connaissances et de
découvrir la recherche informatique publique.
Par ailleurs, je remercie toute l’équipe AlGorille pour leur accueil, et pour m’avoir intégré durant
ce stage.
Également, je tiens à remercier Christophe THIÉRY, Marion GUTHMULLER et Sebastien BADIA
pour leurs réponses à toutes mes questions, nombreuses durant ce stage.
D’une manière générale, je tiens à remercier le LORIA.
Je remercie également Mme ESCUDIE pour son encadrement, ainsi qu’à toute l’équipe de l’IUT
pour m’avoir permis de mener à bien ce stage.
4
INTRODUCTION
Introduction
Aujourd’hui, les environnements distribués prennent une place de plus en plus importante dans
l’informatique : ceux-ci deviennent de plus en plus complexes, sont soumis à de plus en plus de
contraintes. Les architectures pair à pair font parti des environnements distribués les plus étudiés
aujourd’hui.
Or, comme expliqué dans The state of peer to peer simulators and simulations[9], il n’existait pas
jusqu’à présent de simulateur standard pour le pair à pair répondant à tous les critères et utilisé
de façon globale : la plupart (62%) des articles scientifiques utilisent un simulateur spécifiquement
développé pour l’occasion, et une partie n’en utilisaient pas du tout.
L’objectif de ce stage était donc de répondre à cet article scientifique en proposant SimGrid comme
réponse. SimGrid disposait déjà de quasiment tout les éléments pour permettre la simulation d’algo-
rithmes pair à pair, seulement deux étant manquants : Tout d’abord, le manque d’exemples d’implé-
mentation d’algorithmes pair à pair classiques de la littérature pour les utilisateurs. Ensuite, l’interface
Java ne possédait pas toutes les fonctionnalités de l’interface C et avait des problèmes importants de
performances. Or, les utilisateurs souhaitent souvent pouvoir écrire leurs simulations dans un lan-
gage plus haut niveau que le C, et Java est aujourd’hui un langage répandu, très demandé par les
utilisateurs, et utilisé par la majorité des simulateurs pair à pair aujourd’hui.
Dans le cadre de mon stage de fin de DUT, j’ai ainsi pu faire divers travaux sur le simulateur
SimGrid, sur deux axes principaux : l’implémentation d’algorithmes pair à pair et l’amélioration des
interfaces utilisateurs, notamment l’interface Java.
Je vais donc tout d’abord évoquer le contexte dans lequel s’est effectué mon stage, en présentant
le LORIA, l’équipe AlGorille ainsi que le projet SimGrid. Ensuite, je développerai en détail mes
contributions dans le projet SimGrid sur les implémentations d’algorithmes pair à pair ainsi que sur
l’amélioration des interfaces utilisateurs, avant de faire un bilan sur l’avancement actuel.
5
1 / 29 100%
La catégorie de ce document est-elle correcte?
Merci pour votre participation!

Faire une suggestion

Avez-vous trouvé des erreurs dans linterface ou les textes ? Ou savez-vous comment améliorer linterface utilisateur de StudyLib ? Nhésitez pas à envoyer vos suggestions. Cest très important pour nous !