Systèmes distribués : Simgrid, maître-esclave versus vol

Systèmes distribués : Simgrid, maître-esclave
versus vol de travail
Grégory Mounié
Ensimag - 3A ISI
Ce tp vise trois objectifs différents:
• d’une part, l’utilisation de la simulation comme outil scientifique. L’outil
de simulation utilisé sera Simgrid.
• de coder deux schémas génériques: un maître esclave et un vol de travail
• de faire l’étude du passage à l’échelle des deux algorithmes.
La documentation de Simgrid est disponible dans le répertoire file:////
usr/share/doc/simgrid .
1
Algorithmes
Nous cherchons ici à programmer deux algorithmes différents d’équilibrage de
charge dans le but de simuler (en partie) le projet développé dans ce cours
(exécution distribuée de Makefiles). L’un des algorithmes fonctionne de manière
centralisé. L’autre fonctionne de manière décentralisé.
Le schéma maître-esclaves classique distribue une tâche sur chaque machine.
Dès qu’une machine devient inactive, elle renvoie le fichier calculé sur le maître
qui lui distribue une nouvelle tâche, en réalisant au préalable les transferts de
tous les fichiers non présents sur la machine cible à partir du maître.
L’algorithme de vol de travail est implanté en ayant un fonctionnement plus
uniforme. Chaque worker possède une file d’attente des taches lui restant à
faire. Lorsqu’un worker est libre, il va voler du travail à l’un de ses voisins.
2
2.1
Les bases de Simgrid (MSG)
Les communications
Les communications utilisent la notion de task. Une task correspond à l’envoi
d’une quantité de travail et de données d’un noeud à l’autre. Pour faciliter la
programmation, un noeud n’a pas besoin de savoir à qui envoyer précisement la
donnée. Il va simplement nommer la boîte aux lettre. A la réception il suffit de
donner le même nom pour obtenir la task.
1
2.1.1
Exemple: un envoi entre deux processus
#include "msg/msg.h"
#include "xbt/log.h"
XBT_LOG_NEW_DEFAULT_CATEGORY(msg_test, "Mini SR");
int sender(int argc, char *argv[]) {
msg_task_t task = NULL;
task = MSG_task_create("LeNomDeLaTache", 1E9, 1E6, NULL);
MSG_task_send(task, "LeNomDeLaBoite");
return 0;
}
int receiver(int argc , char **argv) {
msg_task_t task=NULL;
MSG_task_receive(& task, "LeNomDeLaBoite");
MSG_task_execute(task);
XBT_INFO("Fin de la tache %s à %g", task->name, MSG_get_clock());
return 0;
}
int main(int argc, char **argv) {
MSG_init(& argc, argv);
MSG_create_environment("cluster.xml");
MSG_function_register("sender", sender);
MSG_function_register("receiver", receiver);
MSG_launch_application("application.xml");
int res = MSG_main();
return 0;
}
2.2
La plateforme
Un système autonome (AS) peut être décrit en donnant la caractéristique de
chaque machine. Mais, une plateforme homogène peut être décrite de manière
beaucoup plus concise.
2.2.1
Description d’une grappe (cluster.xml)
<?xml version=’1.0’?>
<!DOCTYPE platform SYSTEM "http://simgrid.gforge.inria.fr/simgrid.dtd">
<!-_________
|
|
| router |
____________|__________|_____________ backbone
|
|
|
|
|
|
l0| l1| l2|
l97| l96 |
| l99
2
|
|
|
c-0.me
|
........
|
|
|
|
c-99.me
-->
<platform version="3">
<AS id="AS0" routing="Full">
<cluster id="my_cluster_1" prefix="c-" suffix=".me"
radical="0-99" power="1000000000"
bw="125000000"
bb_bw="2250000000" bb_lat="5E-4"/>
</AS>
</platform>
2.3
2.3.1
lat="5E-5"
Le déploiement
Exemple de déploiement pour le code précédent (application.xml)
<?xml version=’1.0’?>
<!DOCTYPE platform SYSTEM "http://simgrid.gforge.inria.fr/simgrid.dtd">
<platform version="3">
<process host="c-0.me" function="sender"/>
<process host="c-1.me" function="receiver"/>
</platform>
3
Codage des deux algorithmes en MSG
Le travail consiste à exécuter 10000 tâches de 1 milliard de flop pesant chacune
1 Mo de données.
3.1
Le maître-esclave
Le processus maître envoie les données les unes après les autres aux esclaves
qui les exécutent. Une seule boîte au lettre et les appels bloquants de l’exemple
précédent devraient suffire.
3.2
Le vol de travail
Il va falloir modéliser un échange distribué de travail. Chaque worker réalise
une boucle de la forme suivante :
int ma_quantite_de_travail;
while(pas_fini) {
if ( ma_quantite_de_travail == 0 ) {
envoie_requete_vol( victime_au_hasard() );
t = recevoir_reponse();
ma_quantite_de_travail += t;
}
else {
if ( test_requete_vol() ) {
3
recevoir_requete_vol();
vol = ma_quantite_de_travail / 2;
ma_quantite_de_travail -= vol;
t = construire_tache(vol)
envoie_reponse( t );
reposter_requete_vol_asynchrone();
continue;
}
construire_tache_unitaire();
executer_tache_unitaire();
pas_fini--;
}
}
Vous pouvez "tricher" pour implanter le simulateur de votre algorithme par
exemple en utilisant une variable globale pour détecter la terminaison, etc.
Chaque processus aura besoin d’une boîte aux lettres. Vous utiliserez sprintf
pour contruire leur noms.
4
Expériences
À vous de réaliser vos expériences. Que remarquez-vous ? Ces conclusions vous
paraissent-elles explicables ? Quels sont vos paramètres d’expérimentations ?
Quels impacts ont-ils sur vos conclusions ? Quelle confiance avez-vous dans vos
conclusions ? Pourriez-vous expliquer à quelqu’un comment refaire ces expériences et obtenir des résultats similaires ?
4