Nous allons illustrer le fonctionnement de l'environnement de simulation
sur l'exemple de calcul distribué, développé pour la modélisation
de sections efficaces.
Pour calculer les sections efficaces de production des espèces,
lors de la réalisation des réactions chimiques possibles entre
et
,
il faut réaliser un grand nombre de trajectoires pour avoir une bonne
statistique. Pour ce faire, nous devons changer légèrement les conditions
initiales. Les réalisations étant indépendantes, leur traitement peut
être effectué en parallèle. Ainsi, nous avons réalisé des scripts de lancement
de simulations de trajectoires, en modifiant la graine du générateur de nombres aléatoires.
De ce fait les trajectoires sont tirées avec des conditions initiales
différentes. De cette façon il a été possible d'écrire un script global
qui permet de lancer des trajectoires, dont les résultats sont stockés dans un ensemble
de répertoires, en exécutant le script de lancement dans chacun des répertoires avec
des conditions initiales différentes.
Une fois l'exécution automatique de trajectoires différentes possibles, il faut lancer ces trajectoires sur plusieurs ordinateurs différents. De cette façon nous pouvons utiliser des conditions de parallélismes naturelles. Pour ce faire nous avons choisi une configuration en étoile du réseau, c'est-à-dire avec un ensemble de clients autour d'un unique serveur. Ce serveur doit être capable de lancer les tâches sur des disques propres à chaque ordinateur de la grappe, pour ne pas écraser les données obtenues. Plusieurs possibilités sont envisageables pour ce faire. Nous pourrions automatiser un FTP (File Transfert Protocol) pour transmettre les données sur chacun des clients. Nous pourrions aussi utiliser la commande "scp". Un autre voie possible est de partager les disques durs des ordinateurs via un montage NFS (Network File System). Nous avons opté pour le montage NFS car c'était le type d'installation qui était déjà préinstallé dans les salles informatiques. Ainsi, l'existence d'un répertoire commun avec toutes les machines suggère de créer un répertoire qui sera le répertoire de travail courant de chacun des clients. Pour lancer la trajectoire sur l'un des clients, nous avons utilisé le programme de contrôle à distance crypté "ssh" (Secure SHell). Ce programme permet, par copie des clefs privées RSA dans un répertoire caché ( ) de s'identifier automatiquement sur les machines distantes. Une fois débarrassé de la demande de mot de passe avant connexion, il devient possible de scripter les lancements de connections sur l'ensemble des ordinateurs constituant la grappe de calcul. L'utilisation de "ssh" permet le lancement d'un script sur l'ordinateur client au moment de la connexion. Ainsi, nous pouvons lancer la génération d'un fichier d'entrée dans le répertoire propre à la machine cliente, puis lancer une simulation sur ce fichier d'entrée et en générer les résultats (un ou plusieurs fichiers de sortie) dans le même répertoire. Ainsi, nous commençons par créer un répertoire par machine qui contient des fichiers d'entrée d'une simulation avec un script shell d'initialisation du calcul des sections efficaces, contenu dans le répertoire /bin:
> more ./bin/init_sim.bash
#/bin/bash nb_computer=5 i=1 while((i<$nb_computer)) do #we create one directory by computer mkdir $i #we make an input file by modifing the ramdom seed in each directory sed "s/random_seed/$i/g" ../template/input_cross_sec.in > ../simulation/cross_section_1/$i/input.in #we copy the shell script that we want to use for the simulation cp ./bin/launch_a_sim.bash ./simulation/cross-section_1/$i/ cp ./bin/stop_a_sim.bash ./simulation/cross-section_1/$i/ cp ./bin/other_script.bash ./simulation/cross-section_1/$i/ ((i=i+1)) done
Le fichier de lancement d'une simulation est simplement constitué pour initialiser les paramètres nécessaires à une simulation. Ainsi, nous obtenons l'arborescence qui va contenir les simulations. Cette arborescence est partagée par tous les ordinateurs de la grappe. Nous lançons la simulation:
> more ./bin/start_a_sim.sh
#/bin/bash #go in the directory $1 cd ../simulation/cross-section_1/$1 #launch simulation echo "lauch simulation in " pwd setenv LD_LIBRARY_PATH "../../../motor-simulation/venus-mopac/lib/" screen -d -m nohup ../../../motor-simulation/venus-mopac/venusmopac.e < ./input.in > ./ output.out
Ce script attend un paramètre qui est le numéro de la machine dans le réseau
c'est-à-dire le numéro du répertoire dans lequel doit être lancé la simulation.
Ce fichier permet de lancer une simulation dans ce que nous appelons un screen, ce
qui permet de détacher le processus de lancement pour être en mesure de couper
la connexion en "ssh". Nous utilisons dans ce cas le moteur de simulation
du programme venus-mopac que nous irons chercher à partir du répertoire de
la simulation courante ( d'où l'utilisation du "../../../motor-simulation" ).
Au moment du lancement de chacun des programmes de simulation, il est possible
d'effectuer des tâches annexes en ajoutant des commandes dans ce script de lancement
qui sera exécuté sur chacun des clients. Nous pouvons ainsi, par exemple, diminuer
la priorité de l'exécution de la simulation, vérifier la présence d'anciennes simulations,
ou déplacer l'ensemble des répertoires dans un autre dossier.
Nous voudrons aussi pouvoir stopper une ou plusieurs simulations automatiquement.
Nous avons donc copié aussi le script pour stopper une simulation lorsque nous nous trouvons
sur l'un des ordinateurs clients. Pour ce faire nous récupérons l'identifiant de
processus (pid) pour le détruire ensuite avec la commande kill.
> more ./bin/stop_a_sim.bash
#/bin/bash PROC_ID=`ps -a | grep -v grep | grep venus-mopac | awk '{print $1}'` echo "we kill the process " echo $PROC_ID kill -9 $PROC_ID
L'environnement est maintenant prêt pour lancer et stopper une exécution dans chacun des répertoires du partage NFS sur chacune des machines présentes dans la grappe. Nous pouvons donc lancer la simulation en appelant un programme de lancement de trajectoire en parallèle. Nous pouvons lancer un ensemble de requêtes "ssh" qui exécuteront la simulation dans le répertoire qui lui est propre avec la commande :
> more ./bin/start_all_sim.bash
#/bin/bash nb_computer=5 i=1 while((i<$nb_computer)) do "ssh" user@netmask.$i ./bin/start_a_sim.bash $i ((i=i+1)) done
En lançant cet unique script nous lançons l'exécution de la simulation correspondante au fichier de paramètre dans le répertoire du numéro de l'ordinateur client. Ainsi, les espaces disque de chaque machine sont séparés et se remplissent avec un processus lancé par tous les "ssh" sur tous les clients. Dans cet exemple j'ai pris cinq clients, mais dans l'école nous disposions de 125 machines clientes réparties en cinq salles. Nous pouvons stopper les simulations sur tous les ordinateurs de la même façon, en appelant le script d'arrêt des simulations sur chaque machine:
> more stop_all_sim.bash
#/bin/bash nb_computer=5 i=1 while((i<$nb_computer)) do "ssh" user@netmask.$i ./bin/stop_a_sim.bash ((i=i+1)) done
De la même façon nous pouvons faire tous traitements locaux sur les clients
par l'écriture d'un seul script approprié dans le répertoire bin.
Analyse des résultats
Ce genre de méthode pour lancer des simulations permet d'obtenir un
grand nombre de résultats, qui peut même parfois être impressionnant.
En effet nous pouvons, avec suffisamment d'ordinateurs, obtenir plusieurs Go
de résultats. Traiter manuellement les résultats peut se révéler très
fastidieux, voire impossible.
La structure bien organisée en répertoires, numérotée par machine, qui contient
les résultats obtenus pour chaque machine, permet de lancer un traitement dans chacun des
répertoires. Dans le cas du calcul de sections efficaces de productions
des différents produits possibles, il s'agit de compter les molécules produites.
Pour ce faire il suffit d'écrire un programme qui prend en entrée un des fichiers
de résultats de "./motor-simulation" et qui retourne le nombre de molécules produites.
Ainsi nous pouvons le lancer en chaîne de la même façon que précédemment, avec les deux
scripts, de démarrage total et d'arrêt total. Nous pouvons ainsi faire toutes les analyses
souhaitées en écrivant le programme approprié que nous lancerons automatiquement dans chaque
répertoire.
Pour analyser le produit de la réaction nous écrivons donc un programme en C++, qui calcule toutes les distances inter-atomiques après un temps de simulation suffisamment grand pour que tous les produits soient suffisamment distants les uns des autres, pour pouvoir être différenciés. Un ensemble de tests entre les distances des atomes mis en jeu, permet de déduire quels sont les produits formés. Nous comptons ensuite les quantités de molécules de et nous sortons ce résultat dans un nouveau fichier de données. En effectuant ensuite la somme des données de tous les fichiers de résultats, nous pouvons avoir une statistique très bonne dans le calcul des sections efficaces.
quentin 2007-09-05