Développement sur cluster d'une application …web.soccerlab.polymtl.ca › ~ducloset › projets...

Institut Supérieur d'Informatique de Modélisation et de leurs Applications

Rapport de projet de troisième année d'école d'ingénieurFilière 2 : génie logiciel et système informatique

Filière 4 : Calcul et modélisation scientifiques

Développement sur cluster d'uneapplication d'optimisation de

transport public

Auteurs :Etienne DuclosGuillaume Mercat

Durée : 120h

Responsables ISIMA :Bruno Bachelet

Loïc Yon

2009 – 2010

Développement sur cluster d'une application d'optimisation de transport public Remerciements

Remerciements

Nous tenons à remercier toutes les personnes qui nous ont aidés de près ou de loin durant notre projet. Nous pensons ainsi à Jin Jin Li, pour son aide concernant l'utilisation de MPI. Et nous pensons aussi à Dr. Roger Hillson, membre du « Naval Research Laboratory » pour nous avoir fourni son programme C++2MPI.

Nous remercions aussi chaleureusement nos maitres de projet, Bruno Bachelet et Loïc Yon, pour leur aide et leur soutien qu'ils nous ont apporté tout au long de notre projet.

Rapport de projet 2010

Développement sur cluster d'une application d'optimisation de transport public Table des figures

Table des figures

Figure 1 : algorithme de grasp non parallélisé.............................................5

Figure 2 : algorithme de tabou non parallélisé............................................7

Figure 3 : Grasp parallélisé avec envoi de géodésiques.................................9

Figure 4 : le nœud maître attend toutes les géodésiques ...........................10

Figure 5 : le nœud maître continue à chaque arriver..................................10

Figure 6 : Grasp parallélisé avec envoi de voisinages.................................11

Figure 7 : algorithme de Tabou parallélisé................................................12

Figure 8 : exemple d'utilisation de ProActive.............................................16

Figure 9 : exemple d'utilisation de MPI.....................................................19

Figure 10 : envoi des données aux esclaves avec grasp..............................20

Figure 11 : réception des données par les esclaves avec grasp....................21


Développement sur cluster d'une application d'optimisation de transport public Résumé

Résumé

Grâce aux nouvelles technologies parallèles, telles les ordinateurs multiprocesseurs et/ou multicœurs, et les clusters, la parallélisation est une technique de plus en plus utilisée. Le gain de temps, et donc de performances, espéré pousse les informaticiens à revoir leurs codes pour profiter de cette avancée.

Il existe de nombreuses méthodes permettant de paralléliser un code, que ce soit via un compilateur spécial ou en utilisant des librairies « parallèles », telle MPI.

Dans le cas de méthodes heuristiques, telles Tabou et Grasp, la parallélisation peut avoir plusieurs avantages. On peut par exemple explorer plus de solutions possibles en un même temps, ou espérer trouver la solution optimale plus rapidement. Cela engendre cependant des complications, telle la gestion de la liste Tabou pour la méthode du même nom.

Mots clés : clusters, parallélisation, MPI, méthodes heuristiques

Abstract

Thanks to the new parallels technologies, such as multiprocessor and/or multi-core computers, and clusters, parallelization is more and more used. The hope to gain time, and so performances, makes computer scientists build new code, in order to use this technology.

There is a lot of methods used to parallelize a code. You can use a specific compiler, or “parallels” libraries, such as MPI.

Using this with heuristic methods, such as Taboo and Grasp, have many advantages. We can, for example, explore more possible solutions in the same time. We can also try to find the optimal solution quicker. However this is engendering some problems, such as the gestion of the taboo list, for this method.

keywords : cluster, parallelization, MPI, heuristic methods


Table des matières Développement sur cluster d'une application d'optimisation de transport public

Remerciements

Table des figures

Résumé

Abstract

Table des Matière s

Introduction 1

1 Présentation 31.1 Géodésiques.................................................................................................3

1.1.1 Définitions...........................................................................................31.1.2 Voisinages...........................................................................................31.1.3 Passage d’un circuit quelconque à une géodésique...........................4

1.2 GRASP sans parallélisation...........................................................................41.2.1 Recherche locale................................................................................41.2.2 Diversification.....................................................................................51.2.3 Algorithme..........................................................................................5

1.3 TABOU sans parallélisation..........................................................................61.3.1 Recherche locale sous contrainte.......................................................61.3.2 Aspiration............................................................................................61.3.3 Algorithme..........................................................................................7

2 Paralléli sation 92.1 Grasp............................................................................................................9

2.1.1 Méthode 1 : envoi de géodésiques.....................................................92.1.2 Méthode 2 : envoi de voisinage........................................................10

2.2 Tabou.........................................................................................................122.2.1 Algorithme........................................................................................122.2.2 Gestion de la liste tabou...................................................................13

3 Méthodes de paralléli sation 153.1 Méthodes en Java.......................................................................................15

3.1.1 Parallel JAVA Library.........................................................................153.1.2 ProActive...........................................................................................153.1.3 RMI....................................................................................................17

3.2 MPI.............................................................................................................183.2.1 Description........................................................................................183.2.2 Exemple............................................................................................193.2.3 Utilisation..........................................................................................20

Conclusion 22

Références bibliographiques


Développement sur cluster d'une application d'optimisation de transport public Introduction

Introduction

Les calculs réalisés de nos jours étant de plus en plus complexes, le temps qu'il faut pour les résoudre devient rédhibitoire. Heureusement, l'apparition des processeurs multicœurs, des architectures multiprocesseurs et l'utilisation de plus en plus ouverte des clusters ouvre de nouvelles possibilités de programmation, appelées programmation parallèle, permettant de réduire grandement les temps de calcul. Coupler ces technologies avec l'utilisation d'heuristiques permet d'espérer résoudre des problèmes non polynomiaux en des temps acceptables et exploitables.

Le problème sur lequel nous avons travaillé concerne le transport urbain dans une grande ville, Clermont-Ferrand. Il s'agit d'un problème d'optimisation visant à proposer une solution de transport à un organisme de gestion en essayant de respecter au mieux les désirs des clients.

L'objectif de notre projet est de développer une version parallèle sur cluster d'un algorithme permettant de résoudre ce problème. Pour cela nous disposions d'une version séquentielle en C++ des algorithmes utilisés.

Dans un premier temps nous présenterons les outils utilisés par le programme, telles les heuristiques. Nous expliquerons ensuite comment nous comptons paralléliser l'application, avant d'enfin exposer les différentes technologies existantes pour la programmation parallèle, en nous concentrant plus particulièrement sur celle que nous avons utilisé : MPI.

Rapport de projet 2010 1

Première partie

Présentation

Développement sur cluster d'une application d'optimisation de transport public 1 Présentation

1 Pré sentation

1.1 Géodésiques

Une géodésique est une structure qui décrit de manière simple un circuit et qui offre des facilités de manipulation. Cette structure est utilisée dans l’implémentation des différentes métaheuristiques considérées.

1.1.1 Définitions

On appelle chemin géodésique un plus court chemin entre deux sommets d’un graphe. Soit P un chemin géodésique, on note origine(P) (respectivement destination(P)) le premier (respectivement dernier) sommet de P.

On appelle Q-géodésique tout ensemble ordonné de Q (avec Q ≥ 2) chemins géodésiques {P0,…, PQ-1} tels que :

origine(Pi) = destination (P(i+Q-1)[Q]) i = [0,…, Q-1] ou encore destination(Pi) = origine(P(i+1)[Q]) i = [0,…, Q-1]

avec modulo Q noté [Q].

On appelle géodésique, toute Q-géodésique dont le nombre de chemins géodésiques n’est pas spécifié.

On appelle point de contrôle de la géodésique toute extrémité d’un chemin géodésique d’une géodésique. Une géodésique a autant de points de contrôle qu’elle a de chemins géodésiques. On appelle encore ordre d’une géodésique le nombre de points de contrôle/de chemins géodésiques. Une Q-géodésique peut être caractérisée complètement par la donnée de ses Q points de contrôle.

On dit que deux géodésiques sont équivalentes si les deux géodésiques décrivent exactement la même suite ordonnée d’arcs à une rotation près, c'est-à-dire si elles décrivent le même circuit.

Pour de plus amples renseignements, on pourra se référer à la thèse de Loic Yon ([TLY]).

1.1.2 Voisinages

Les métaheuristiques qui sont implémentées sont classées dans la famille des heuristiques de « recherche locale », c'est-à-dire que l’on explore l’espace des


1.1 Géodésiques Développement sur cluster d'une application d'optimisation de transport public

solutions (réalisables) en passant d’une solution à une autre. Déterminer le voisinage d’une solution, c’est déterminer toutes solutions « voisines », au sens où elles sont obtenues par l’application d’un opérateur dit de voisinage sur cette solution.

Il existe cinq types d’opérateur de voisinage :• Changement de chemin géodésique entre deux points de contrôle.• Déplacement d’un point de contrôle.• Insertion ou suppression d’un point de contrôle.• Ré ordonnancement des points de contrôle.• Redéfinition complète, aléatoire ou contrôlée, de la géodésique.

L'opérateur de voisinage que nous utilisons est celui consistant à déplacer un point de contrôle sélectionné aléatoirement.

1.1.3 Passage d’un circuit quelconque à une géodésique

Pour passer d’un circuit quelconque à une géodésique, on choisit un point du circuit au hasard et ce sera le premier point de contrôle. On choisit ensuite un point du circuit, dans le sens de parcours du circuit, qui constitue le plus grand « plus court chemin » avec le point choisit précédemment. Le chemin ainsi déterminé constitue le premier chemin géodésique de la géodésique. On itère le processus jusqu’à ce que l’on ait couvert complètement le circuit initial.

1.2 GRASP sans parallélisation

GRASP ( Greedy Randomized Adaptive Search Procédure) est apparue dans les années 90. Elle apporte une réponse au problème soulevé par l’exploitation globale de l’espace des solutions pour les procédures de recherche locale. La phase de recherche locale est encapsulée dans un mécanisme plus général de génération contrôlée de solutions. L’heuristique GRASP alterne les phases de recherche locale et les phases de diversification.

1.2.1 Recherche locale

Lors de la recherche locale, l’algorithme prend quelques libertés par rapport à l’algorithme de descente simple. Il n’est pas requis de complètement réaliser la phase de descente : il permet de prendre toute solution qui améliore la solution courante. Dans cette implémentation, on fixe un nombre maximal d’itérations pour la phase de recherche locale. Si la descente est rapide, ce critère n’intervient pas. Si, au contraire, la descente est lente, la phase de descente est arrêtée lorsque le nombre d’itérations est atteint et on relance la recherche dans une autre région de l’espace des solutions.

4 Rapport de projet 2010

Développement sur cluster d'une application d'optimisation de transport public 1.2 GRASP sans parallélisation

1.2.2 Diversification

La diversification est le nom donné à l’opération qui consiste à générer une solution durant le processus de résolution dans le but d’explorer une zone différente de l’espace des solutions. On essaie, dans la mesure du possible, de tirer profit de certaines informations relevées pendant les itérations précédentes pour réellement toucher une région différente. L’idée est donc de couvrir la plus grande zone possible de l’espace des solutions de manière cohérente. L’alternance des phases de diversification et des phases de recherche locale doit permettre de trouver les meilleures solutions possibles.

L’objet manipulé est la géodésique. Elle caractérise un circuit qui peut être vu, soit comme une suite ordonnée d’arcs, soit comme une suite ordonnée de nœuds.

1.2.3 Algorithme

Voici l'algorithme de la méta heuristique grasp :

Tant que (d ≤ div_max) && (iter ≤ iter_max) construire une nouvelle géodésique X ; construire un nouveau voisinage V'(X); iter++; d++;

Tant que (V'(X) non vide) && (liter ≤ liter_max) && (iter ≤ iter_max) prendre X' dans V'(X); X = X'; construire un nouveau voisinage V'(X); Ftq

Si f(X) < f(X*) X* = X; FsiFtq

Figure 1 : algorithme de grasp non parallélisé


1.3 TABOU sans parallélisation Développement sur cluster d'une application d'optimisation de transport public

1.3 TABOU sans parallélisation

Le mécanisme de base de cette métaheuristique est simple : en partant d’une solution initiale, on progresse de proche en proche en sélectionnant le meilleur voisin possible et en interdisant tout retour à une solution récemment explorée, solution que l’on qualifie alors de tabou. Ce n’est pas un algorithme de descente car la meilleur solution voisine n’est pas forcément une solution améliorante de la solution courante.

L’algorithme tabou présenté ici est plus élaboré et se décompose en deux niveaux : la recherche « globale » pilote une recherche « locale » sous contrainte et on procède à une diversification si certains critères d’amélioration ne sont pas réunis.

1.3.1 Recherche locale sous contrainte

On pose une contrainte forte sur le coût de la tournée, et elle n’est pas relâchée. Une conséquence directe est qu’il n’est pas toujours possible d’obtenir un voisin lors de la recherche locale, ou alors on constate que le nombre de voisin devient trop faible. Cette situation peut s’avérer gênante dans la mesure où la métaheuristique a de bien meilleures chances de trouver une bonne solution si elle peut visiter un très grand nombre de solutions. Si on se retrouve dans ce cas de figure, on est tenté de diversifier afin de retrouver des solutions réalisables car la levée de caractères tabou peut permettre de découvrir de bonnes solutions. Le concept d’aspiration prend alors du sens car on peut recouvrir à la diversification dès lors qu’il n’y a plus de solutions réalisables améliorantes.

1.3.2 Aspiration

L’aspiration est la levée du caractère tabou d’une solution dans certaines conditions. La solution utilisée est la suivante : lors de recherche de voisinage, elle consiste à accepter une solution tabou si celle-ci améliore la solution locale. Elle peut augmenter les temps de calculs car elle nécessite d’évaluer tous les voisinages mais elle réduit dans le même temps le nombre d’itérations pour l’obtention de la solution finale. L’utilisation de l’aspiration doit se faire avec précaution dans la mesure où l’on change le comportement de l’algorithme tabou. Avec l’utilisation de ce mécanisme, la méthode tabou se comporte localement comme un algorithme de descente, ce qui peut être parfois préjudiciable.


Développement sur cluster d'une application d'optimisation de transport public 1.3 TABOU sans parallélisation

1.3.3 Algorithme

Dans l'algorithme suivant, représentant la méta heuristique tabou, T est la liste tabou, et P représente la fonction de comparaison de deux coûts.

générer aléatoirement une solution réalisable X0;Xopt = Xloc = X = X0;

Tant que critère 1 Tant que critère 2 sélectionner X' meilleur voisin dans V(X) tel que X' ne soit pas dans T et que l(X') ≤ l_max; incrémenter les g_iter, l_iter, no_g_iter et no_l_iter;

Si X' existe Si P(f(X'), f(X)) Xloc = X'; no_l_iter = no_g_iter = 0; Fsi

mettre X' dans T; no_nb = 0; Sinon no_nb++; Fsi mettre T à jour; Ftq

Si P(f(Xopt), f(Xloc)) Xopt = Xloc; no_g_iter = no_d_iter = 0; Sinon incrémenter no_g_iter et no_d_iter Fsi générer une nouvelle solution réalisable X; vider T; Ftq

Figure 2 : algorithme de tabou non parallélisé


Deuxième partie

Parallélisation

Développement sur cluster d'une application d'optimisation de transport public 2 Parallélisation

2 Paralléli sation

Pour paralléliser les heuristiques nous avons exploré plusieurs pistes, que nous allons vous exposer dans cette partie.

2.1 Grasp

2.1.1 Méthode 1 : envoi de géodésiques

Le première méthode à laquelle nous avons pensé est la suivante :• le nœud maître génère une géodésique par nœud esclave ;• chaque nœud esclave fait la recherche locale sur sa géodésique ;• le nœud maître récupère les solutions et garde la meilleure.

En voici l'algorithme :

Nœud maître :

Tant que (d ≤ div_max) && (iter ≤ iter_max) iter++; d++; Pour chaque esclave construire une nouvelle géodésique X ; envoyer la géodésique;

Fin Pour recevoir les géodésiques; comparer les géodésiques et garder la meilleure : X;


Nœud esclave :

recevoir la géodésique X; construire un nouveau voisinage V'(X); Tant que (V'(X) non vide) && (liter ≤ liter_max) && (iter ≤ iter_max) prendre X' dans V'(X); X = X'; construire un nouveau voisinage V'(X); Ftq envoyer X;

Figure 3 : Grasp parallélisé avec envoi de géodésiques


2.1 Grasp Développement sur cluster d'une application d'optimisation de transport public

Cette méthode peut se coder de deux façons différentes : soit le nœud maître attend que tous les esclaves lui ai renvoyé leur solution avant de choisir la meilleure et de continuer l'algorithme, soit il traite les solutions reçues dès leur arriver sans attendre les autres. Cette différence est montrée dans les figures suivantes.

Figure 4 : le nœud maître attend toutes les géodésiques

L'attente de toutes les géodésiques pour pouvoir continuer l'algorithme permet de les comparer plus facilement. Cependant l'inconvénient majeur vient du fait que la recherche locale se fait à la vitesse du nœud esclave le plus lent.

Au contraire si le nœud maître continue l'algorithme à chaque arriver de géodésique, le fait qu'un esclave mette plus de temps que les autres est gommé. Cependant cela rend plus difficile la gestion du nombre d'itérations pour le nœud maître.

Figure 5 : le nœud maître continue à chaque arriver

2.1.2 Méthode 2 : envoi de voisinage

La deuxième méthode à laquelle nous avons pensé est la suivante :• le nœud maître génère un voisinage par nœud esclave ;• chaque nœud esclave fait la recherche locale sur son voisinage ;• le nœud maître récupère les solutions et garde la meilleure.


Noeuds esclaves

Noeud maître

Noeuds esclaves

Noeud maître

Développement sur cluster d'une application d'optimisation de transport public 2.1 Grasp

En voici l'algorithme :

Nœud maître :

Tant que (d ≤ div_max) && (iter ≤ iter_max) iter++; d++; construire une nouvelle géodésique X; Pour chaque esclave construire un nouveau voisinage V(X); envoyer le voisinage;

Fin Pour recevoir les géodésiques; comparer les géodésiques et garder la meilleure : X;


Nœud esclave :

recevoir le voisinage V'(X); Tant que (V'(X) non vide) && (liter ≤ liter_max) && (iter ≤ iter_max) prendre X' dans V'(X); X = X'; construire un nouveau voisinage V'(X); Ftq envoyer X;

Figure 6 : Grasp parallélisé avec envoi de voisinages

Comme pour la méthode précédente, il y a deux façons de coder : attendre toutes les réponses ou continuer dès qu'une géodésique arrive.


2.2 Tabou Développement sur cluster d'une application d'optimisation de transport public

2.2 Tabou

2.2.1 Algorithme

Pour la méthode Tabou nous n'avons retenue qu'une seule méthode de parallélisation :

• le nœud maître génère une géodésique X0 par nœud esclave ;• chaque nœud esclave fait une recherche tabou ;• le nœud maître récupère les géodésiques et garde la meilleure;

En voici l'algorithme :Nœud maître :Pour chaque nœud esclave générer aléatoirement une solution réalisable X0; envoyer X0;Fin Pour

recevoir les géodésiques;comparer les géodésiques;garder la meilleure;

Nœud esclave : recevoir X0;Xopt = Xloc = X = X0;

Tant que critère 1 Tant que critère 2 sélectionner X' meilleur voisin dans V(X) tel que X' ne soit pas dans T et que l(X') ≤ l_max; incrémenter les g_iter, l_iter, no_g_iter et no_l_iter;

Si X' existe Si P(f(X'), f(X)) Xloc = X'; no_l_iter = no_g_iter = 0; Fsi

mettre X' dans T; no_nb = 0; Sinon no_nb++; Fsi mettre T à jour; Ftq

Si P(f(Xopt), f(Xloc)) Xopt = Xloc; no_g_iter = no_d_iter = 0; Sinon incrémenter no_g_iter et no_d_iter Fsi générer une nouvelle solution réalisable X; vider T; Ftq

envoyer Xopt;

Figure 7 : algorithme de Tabou parallélisé


Développement sur cluster d'une application d'optimisation de transport public 2.2 Tabou

2.2.2 Gestion de la liste tabou

L'un des problèmes de la parallélisation de la méta heuristique tabou est la gestion de la liste tabou. En effet chaque esclave, faisant sa proche recherche locale, va avoir sa propre liste tabou.

Nous n'avons pas développé cette partie. Cependant voici les idées auxquelles nous avons pensé :

• soit le nœud maître est le seul à avoir la liste, auquel cas il y aura beaucoup de communications entre le maître et les esclaves : à chaque fois qu'une géodésique améliorante sera trouvée par un des esclaves, il faudrait en avertir le maître qui lui même devrait éventuellement ré-avertir tout le monde. Cela pourrait poser problème si un esclave est en train d'effectuer la recherche à partir de la géodésique nouvellement insérée. Néanmoins cela permettrait de garder le côté « tabou » de l'heuristique ;

• soit le nœud maître fourni une copie de la liste aux esclaves en même temps que les géodésiques. Chaque esclave gère alors sa liste, et la liste du maître est mise à jour, soit à la fin, soit au bout d'un nombre d'itérations donné. Cependant cela augmente le risque que plusieurs nœuds cherchent sur les mêmes géodésiques, et donc qu'on perde le caractère tabou de l'heuristique. Néanmoins cela implique moins de communication entre les nœuds que la méthode précédente.


Troisième partie

Méthodes de parallélisation

Développement sur cluster d'une application d'optimisation de transport public 3 Méthodes de parallélisation

3 Méthodes de parallélisation

L'une des premières tâches que nous avions à faire fut de rechercher toutes les méthodes possibles pour paralléliser un code, que ce soit en JAVA ou en C++, les deux langages susceptibles d'être utilisés par la suite.

Voici donc un petit résumé de ces solutions, d'abord en JAVA, puis en C++.MPI étant la technologie que nous avons décidé d'utiliser, cette partie sera

logiquement plus développée.

3.1 Méthodes en Java

3.1.1 Parallel JAVA Library

La parallel JAVA Library (aussi appelée PJ) est une API spécialisée pour la programmation parallèle en JAVA ([PJLOW]).

Cette API est utilisable aussi bien sur des machines multiprocesseurs parallèles à mémoire partagée (ou shared memory multiprocessor, SMP), sur des clusters d'ordinateurs, ou sur un hybride de ses types de machines.

Son utilisation requiert JAVA JDK 1.5. Son utilisation avec JDK 1.6 entraine une baisse des performances.

3.1.2 ProActive

3.1.2.1 Description

Il s'agit d'une suite d'outils open source pour la programmation parallèle en JAVA ([PAOW]).

Elle est utilisable sur des ordinateurs multiprocesseurs, sur des clusters ou des grilles de calculs types EGEE (en proposant notamment des interfaces pour pouvoir les utiliser), voir sur des réseaux intranet en peer – to – peer.

Se veut l'équivalent de MPI1 sous JAVA, avec notamment une application permettant de « transposer » un code C++ utilisant MPI en un code JAVA « parallélisé ».

Le transport de l'information entre les différents objets actifs (objet distribués sur le réseau) se fait en utilisant la librairie RMI2 ([PAA]).

Chaque objet actif possède une « racine », qui est l'unique point d'entrée de l'objet, et son propre thread de contrôle qui lui permet de décider dans quel

1 Voir page 182 Voir page 17


3.1 Méthodes en Java Développement sur cluster d'une application d'optimisation de transport public

ordre il traite les appels entrants, qui sont eux même stockés dans une file d'attente.

Les méthodes d'appel aux objets actifs sont asynchrones et fonctionnent selon un mécanisme appelé « wait-by-necessity ».

3.1.2.2 Exemple

Voici un exemple d'utilisation de ProActive tiré du manuel officiel ([PAOM]). Il s'agit du calcul de PI.

// Group creationWorker workers = (Worker) PASPMD.newSPMDGroup(Worker.class.getName(), params,

nodesArray);DoubleWrapper wrappedResult;

while (numOfIterations > 0){ // Send the number of iterations to the first worker Worker firstWorker = (Worker) PAGroup.getGroup(workers).get(0); wrappedResult = firstWorker.start(numOfIterations);}

// ProActive initializationrank = PASPMD.getMyRank();groupSize = PASPMD.getMySPMDGroupSize();

// Get all workers referencesworkersArray = (Worker[]) PAGroup.getGroup(PASPMD.getSPMDGroup()).toArray(new

Worker[0]);

// The leader collects partial results.// Others just send their computed data to the rank 0.if (rank == 0){ for (i = 1; i < groupSize; i++) { body.serve(body.getRequestQueue().blockingRemoveOldest("updateX")); // block until an updateX call sum += x; }}else{ workersArray[0].updateX(sum);}/*** This method will be called remotely by a worker to send its value.** @param value The value to remotely update.*/public void updateX(double value) {this.x = value;}

Figure 8 : exemple d'utilisation de ProActive


Développement sur cluster d'une application d'optimisation de transport public 3.1 Méthodes en Java

3.1.3 RMI

RMI, pour Remote Method Invocation, est une API JAVA permettant de manipuler des objets distants comme s'ils étaient sur la JVM locale ([RMICI]).

Les connexions et transferts de données se font sur TCP/IP, et les communications client – serveur grâce au protocole RMI-IIOP (Internet Inter-Orb Protocol), un protocole normalisé par l'OMG (Object Management Group) et utilisé dans l'architecture CORBA.

Une application en RMI utilise trois composants :• le stub, ou proxy, implémenté par l'application cliente, et qui permet la

communication avec le serveur ;• le skeleton, qui est l'équivalent du proxy, implémenté sur le serveur ;• le registre RMI, qui référence les objets.

Voici les 5 étapes pour créer et utiliser une application utilisant RMI. Ces étapes sont tirées du cours de M. Traoré ([RMICT]).

1) créer et compiler les classes nécessaires (proxy.java, skeleton.java, client.java, serveur.java..) ;

2) créer le proxy via la commande rmic proxy ;3) démarrer le registre via la commande rmiregistry ; 4) lancer le serveur ;5) lancer le(s) client(s) ;

RMI n'est pas à proprement parlé une méthode de parallélisation, mais elle peut être utilisée pour paralléliser dans le sens ou chaque nœud représente un client, et le nœud maître représente le serveur.


3.2 MPI Développement sur cluster d'une application d'optimisation de transport public

3.2 MPI

A la fin de nos recherches, nous avons décidé, en accord avec nos maîtres de projet, que nous utiliserions MPI. En effet le code existant est en C++, et nous avons tout deux eu des cours sur cette technologie lors de notre troisième année. Il nous serait ainsi, en théorie, plus simple d'arriver à paralléliser le programme avec MPI qu'avec une autre technologie, notamment en JAVA. Nous savions de plus que les serveurs de l'ISIMA possèdent les outils nécessaires à l'utilisation de MPI.

3.2.1 Description

MPI (Message Passing Interface) est une bibliothèque de fonctions permettant la programmation parallèle en C, C++ et Fortan sur des systèmes à mémoire distribuée ([MPIW]).

Elle supporte aussi bien la communication point à point, c'est à dire la communication directe entre deux processus, que la communication collective, c'est à dire l'envoi d'un message de la part d'un processus à tous les autres.

Les applications utilisant MPI sont portables, car cette bibliothèque est implémentée pour presque toutes les architectures de mémoire, et rapide, car MPI a été optimisé pour tous type de matériel utilisé.

Son utilisation est relativement simple, car elle résume quasiment à l'utilisation des huit fonctions suivantes ([TMPI]) :

• MPI_Init• MPI_Finalize• MPI_Comm_size• MPI_Comm_rank• MPI_Send, ou MPI_Bcast : Bcast sert à envoyer les opérations depuis un

processus à tous les autres, alors que Send n'envoie qu'à celui spécifié • MPI_Recv, ou MPI_Reduce : Reduce combine les données de tous les

processus et les renvoi à un seul

L'envoi de messages peut se faire de manière synchrone, bloquante, non bloquante et/ou à l'aide du buffer ([MPIT]).


Développement sur cluster d'une application d'optimisation de transport public 3.2 MPI

3.2.2 Exemple

Voici un exemple d'utilisation de MPI tiré d'un tutoriel ([TMPI]). Il s'agit du calcul de PI.

#include "mpi.h" #include <math.h>

int main(argc,argv) int argc; char *argv[]; { int done = 0, n, myid, numprocs, i, rc; double PI25DT = 3.141592653589793238462643; double mypi, pi, h, sum, x, a; MPI_Init(&argc,&argv); MPI_Comm_size(MPI_COMM_WORLD,&numprocs); MPI_Comm_rank(MPI_COMM_WORLD,&myid); while (!done) { if (myid == 0) { printf("Enter the number of intervals: (0 quits) "); scanf("%d",&n); } MPI_Bcast(&n, 1, MPI_INT, 0, MPI_COMM_WORLD); if (n == 0) break; h = 1.0 / (double) n; sum = 0.0; for (i = myid + 1; i <= n; i += numprocs) { x = h * ((double)i - 0.5); sum += 4.0 / (1.0 + x*x); } mypi = h * sum; MPI_Reduce(&mypi, &pi, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD); if (myid == 0) printf("pi is approximately %.16f, Error is %.16f\n", pi, fabs(pi - PI25DT)); } MPI_Finalize(); }

Figure 9 : exemple d'utilisation de MPI


3.2 MPI Développement sur cluster d'une application d'optimisation de transport public

3.2.3 Utilisation

3.2.3.1 Types dérivés

MPI nécessite l'utilisation de types spécifiques pour les fonctions Send et Recv. Les types « de base », tels les entiers ou les caractères, ont tous leurs équivalents en type MPI. Les autres types, telles les classes personnelles ou les vecteurs, nécessitent l'utilisation du type MPI_Datatype et de fonctions spécifiques. Ainsi, lorsque nous voulons envoyer aux esclaves une géodésique3, il faut passer celle ci en type MPI_Datatype.

Le problème majeur que nous avons rencontré est la présence de pointeurs parmi les attributs d'une géodésique, ainsi que des autres classes que nous utilisons. Or en parallélisation les pointeurs n'ont aucun sens : l'adresse d'un objet sur le nœud maître n'aura aucune signification pour le nœud esclave. Nous ne pouvons donc pas « transposer » une géodésique en type MPI_Datatype.

3.2.3.2 Utilisation de vecteurs

Nous avons donc décidé de n'envoyer aux nœuds esclaves qu'un vecteur contenant les points de contrôle de la géodésique. En effet il est possible de reconstruire une géodésique à partir de ses points de contrôle et des données du graphs. Ces données peuvent être stockées dans des vecteurs, respectivement de doubles et d'entiers.

Nous avons donc créé plusieurs fonctions : une permettant de passer du vecteur de points de contrôle à un vecteur de double, contenant les coordonnées des points de contrôle (nécessaire pour pouvoir l'envoyer par MPI, les points de contrôle n'étant pas des types MPI) ; une autre permettant de reconstruire une géodésique à partir de ses points de contrôle. Nous avons enfin dû faire une fonction qui permet le passage du fichier .raw, contenant le graph à proprement parlé, en un vecteur d'entiers, là encore pour pouvoir l'envoyer aux esclaves (le graph est nécessaire dans la reconstruction d'une géodésique).

3.2.3.3 Code

Voici la partie du code concernant l'envoi des données aux esclaves par le nœud maître :

vect2vect(current_geodesic->points, vect_cp);// On envoi les points de controles, le graph aux esclavesMPI_Type_vector(vect_geo1->size(), 1, 1, MPI_INT, &vec);MPI_Type_commit(&vec);MPI_Type_vector(vect_cp->size(), 1, 1, MPI_DOUBLE, &vec2);MPI_Type_commit(&vec2);MPI_Send(&vect_cp, 1, vec2, i, 30, MPI_COMM_WORLD);MPI_Send(&vect_geo1, 1, vec, i, 30, MPI_COMM_WORLD);

3 Voir page 9


Développement sur cluster d'une application d'optimisation de transport public 3.2 MPI

Figure 10 : envoi des données aux esclaves avec grasp

La fonction vect2vect permet de construire le vecteur de double à partir du vecteur de points de contrôle.

La fonction MPI_Type_vector() permet de transformer le vecteur désiré en un vecteur accepté par MPI. La fonction MPI_Type_commit() permet de valider le type précédemment créé. Vect_cp est le vecteur contenant les informations sur les points de contrôle, et vect_geo1 celles du graph.

La réception, chez les esclaves, se fait comme suit :

MPI_Recv(&vect_cp, 1, vec2, 0, 30, MPI_COMM_WORLD, &status);MPI_Recv(&vect_geo1, 1, vec, 0, 30, MPI_COMM_WORLD, &status);// On reconstruit la geodesiquecp_nb = vect_cp->size();current_geo = construire<TU_GRAPH>(vect_geo1, cp_nb, vect_cp);

Figure 11 : réception des données par les esclaves avec grasp

La fonction construire permet de reconstruire la géodésique à partir du graph et de ses points de contrôle.

Nous avons ainsi pu envoyer une géodésique aux nœuds esclaves, et en envoyer depuis les nœuds esclaves. Nous n'avons cependant pas fait le passage de voisinages, comme mentionné dans la méthode 24.

Cependant, l'utilisation du logiciel C++2MPI, réalisé par les docteurs Hillson et Iglewski ([C++2MPI]), qui permet de créer des types MPI directement à partir de classes C++, pourrait éventuellement nous éviter tous ces détours. Après quelques échanges de mails, M. Hillson nous a fourni la dernière version du programme. Nous n'avons cependant pu le tester par manque de temps. De plus il semblerait, d'après M. Hillson, que le code ne soit plus à jour.

4 Voir page 10


Conclusion Développement sur cluster d'une application d'optimisation de transport public

Conclusion

Le but de notre projet était de concevoir une version parallèle d'un algorithme d'optimisation d'un problème de transport public urbain. Pour cela nous avons dans un premier temps mené une étude portant sur les différentes technologies existantes pour la programmation parallèle. Suite à cette étude nous avons choisi d'utiliser la librairie MPI, pour le langage C++, car en plus des bases acquises en cours, nous pouvions nous référer à nos professeurs pour les problèmes rencontré, ce qui n'était pas forcément le cas avec les autres technologies. Dans un second temps nous avons analysé les algorithmes séquentiels existants afin de déterminer différentes manières de les paralléliser, pour ensuite les implémenter.

Lors de la phase d'implémentation nous avons rencontré plusieurs problèmes. Nous voulions tout d'abord adapter les classes existantes en type MPI pour pouvoir les utiliser, avant de nous rendre compte finalement que cela n'était en fait pas possible à cause de la présence de pointeurs dans les classes.

Nous avons ensuite tenté de stocker les objets que nous voulions utiliser dans des vecteurs, mais là encore cela n'était pas possible car demandait le stockage de trop de données.

Une fois la bonne solution trouvée (stocker uniquement les données des points de contrôle), nous avons ensuite passé du temps à trouver comment régler notre environnement de travail (le serveur solaire) afin de pouvoir compiler puis exécuter notre programme.

Au moment où nous écrivons cette conclusion, le programme bloque apparemment lors de la réception d'un vecteur, et nous n'arrivons pas encore à voir pourquoi.

Ces problèmes nous viennent en grand partie du fait que nous avons des connaissances de base en MPI, et que les tutoriels disponibles sur internet ne traitent que rarement le cas du C++, au profit du C et du Fortran.

Lors de nos recherches, nous sommes entrés en contact avec un chercheur Américain, M. Hillson, qui a travaillé sur un logiciel permettant de traduire une classe C++ en type MPI. Nous n'avons cependant pas eu le temps de pousser plus amplement nos recherches. Cela pourrait simplifier la parallélisation de l'algorithme. Il semblerait de plus que la bibliothèque Boost.MPI gère plus le C++ que la librairie MPI de base. Là encore nous n'avons pas eu le temps de nous y intéresser plus particulièrement.


Développement sur cluster d'une application d'optimisation de transport public Bibliographie

Bibliographie

[TLY] : Loïc Yon, Modèles et outils pour la conception stratégique de réseaux de transports publics, 2005

[PJLOW] : A. Kaminsky , Site officiel de la Parallel JAVA Library, http://www.cs.rit.edu/~ark/pj.shtml

[PAOW] : INRIA, Activeeon, Site officiel de la suite ProActive, http://proactive.inria.fr/

[PAA] : C. Massol, Outils d’analyse statique et de vérification pour les applications Java distribuées, 2004

[PAOM] : The OASIS Research Team, ActiveEon, ProActive Programming,

[RMICI] : Introduction au RMI de commentcamarche, http://www.commentcamarche.net/contents/rmi/rmiintro.php3

[RMICT] : M.K Traoré, Cours de programmation réseaux

[MPIW] : Wikipedia, MPI, http://fr.wikipedia.org/wiki/Message_Passing_Interface

[TMPI] : W. Gropp , Tutorial on MPI, http://www.mcs.anl.gov/research/projects/mpi/tutorial/gropp/talk.html

[MPIT] : Blaise Barney, Tutoriel sur MPI, https://computing.llnl.gov/tutorials/mpi/

[C++2MPI] : Hillson, R. Iglewski, M., C++2MPI: a software tool for automatically generating MPI datatypes from C++ classes, 2000


Développement sur cluster d'une application …web.soccerlab.polymtl.ca › ~ducloset › projets...

Documents

Transcript of Développement sur cluster d'une application …web.soccerlab.polymtl.ca › ~ducloset › projets...