4 Lancement d'une application Salomé dans un gestionnaire de Batch
5 ================================================================
7 Cette section explique comment utiliser Salomé avec les gestionnaires
8 de batch qui sont utilisés dans l'exploitation de clusteurs.
9 L'objectif est de lancer une application Salomé avec un script de commande sur un clusteur à partir
10 d'une session Salomé lancée sur la machine personnelle de l'utilisateur. Le script
11 contient la tâche que l'utilisateur veut que Salomé exécute. Il s'agit le plus souvent
12 du lancement d'un schéma YACS.
17 Le principe du lancement est le suivant: depuis une première session Salomé, une application
18 Salomé est lancée sur le clusteur par le biais du gestionnaire de batch. Il y a donc deux
19 installations de Salomé: une sur la machine de l'utilisateur et une autre sur le clusteur.
20 Sur le clusteur, l'utilisateur doit avoir un compte, y avoir accès en lecture/écriture. De plus, il doit
21 avoir configuré correctement le protocole de connexion depuis son poste, qu'il utilise rsh ou ssh.
23 La suite de ce chapitre détaille les différentes étapes du lancement. Tout d'abord, une application Salomé
24 est lancée sur la machine de l'utilisateur avec un fichier CatalogResources.xml contenant la description
25 de la machine batch visée (voir :ref:`catalogresources_batch`). Ensuite, l'utilisateur appelle le service de Salomé pour
26 le lancement sur machine batch. Pour cela, l'utilisateur décrit les fichiers d'entrées et de sorties de l'application
27 Salomé lancée en batch ainsi que du script python à lancer (voir :ref:`service_launcher`). Ce service
28 lance ensuite l'application Salomé définit dans le fichier CatalogResources.xml sur la machine batch et
29 exécute le fichier de commande python (voir :ref:`salome_clusteur_batch`).
31 .. _catalogresources_batch:
33 Description du clusteur par le biais du fichier CatalogResources.xml
34 --------------------------------------------------------------------
36 Le fichier CatalogResources.xml contient la description des différentes ressources de calcul (machines)
37 distribuées que Salomé peut utiliser pour lancer ses containers. Il peut aussi contenir la description de
38 clusteurs administrés par des gestionnaires de batch.
40 Voici un exemple de description d'un clusteur:
44 <machine hostname="clusteur1"
51 appliPath="/home/user/applis/batch_exemples"
52 batchQueue="mpi1G_5mn_4p"
53 userCommands="ulimit -s 8192"
54 preReqFilePath="/home/ribes/SALOME4/env-prerequis.sh"
61 Voici la description des différents champs utilisés dans un lancement batch:
63 - **hostname**: nomme le clusteur pour les commandes de Salomé. Attention, ce nom n'est pas
64 utilisé pour identifier le frontal du clusteur.
65 - **alias**: nomme le frontal du clusteur. Ce nom de machine doit être atteignable par le protocole
66 définit dans le fichier. C'est cette machine qui sera utilisé pour lancer la session batch.
67 - **protocol**: fixe le protocole de connexion entre la session utilisateur et le frontal du clusteur.
68 Choix possibles: **rsh** ou **ssh**.
69 - **userName**: nom de l'utilisateur sur le clusteur.
70 - **mode**: identifie la description de la machine comme un clusteur géré par un batch.
71 Choix possibles: **interactive** ou **batch**. Pour que la machine soit prise en compte comme étant un clusteur
72 avec un gestionnaire de batch, il faut choisir l'option **batch**.
73 - **batch**: identifie le gestionnaire de batch. Choix possibles: **pbs**, **lsf** ou **sge**.
74 - **mpi**: Salomé utilise **mpi** pour lancer la session Salomé et les containers sur les différents noeuds
75 de calcul alloués par le gestionnaire de batch. Choix possibles: **lam**, **mpich1**, **mpich2**, **openmpi**,
76 **slurm** ou **prun**. Il faut noter que certains gestionnaires de batch remplacent le lanceur de mpi
77 par leur propre lanceur pour la gestion des ressources, d'où les options **slurm** et **prun**.
78 - **appliPath**: contient le chemin de l'application Salomé préalablement installée sur le clusteur.
80 Il existe deux champs optionnels qui peuvent être utiles selon la configuration des clusteurs:
82 - **batchQueue**: spécifie la queue du gestionnaire de batch à utiliser.
83 - **userCommands**: permet d'insérer du code **sh** lors du lancement de Salomé. Ce code est exécuté sur tous
89 Utilisation du service Launcher
90 -------------------------------
92 Le service Launcher est un serveur CORBA lancé par le noyau de Salomé. Son interface est décrite dans le
93 fichier **SALOME_ContainerManager.idl** du noyau.
99 interface SalomeLauncher
101 long submitJob( in string xmlExecuteFile,
102 in string clusterName ) raises (SALOME::SALOME_Exception);
103 long submitSalomeJob( in string fileToExecute,
104 in FilesList filesToExport,
105 in FilesList filesToImport,
106 in BatchParameters batch_params,
107 in MachineParameters params ) raises (SALOME::SALOME_Exception);
109 string queryJob ( in long jobId, in MachineParameters params ) raises (SALOME::SALOME_Exception);
110 void deleteJob( in long jobId, in MachineParameters params ) raises (SALOME::SALOME_Exception);
112 void getResultsJob( in string directory, in long jobId, in MachineParameters params )
113 raises (SALOME::SALOME_Exception);
115 boolean testBatch(in MachineParameters params) raises (SALOME::SALOME_Exception);
121 La méthode **submitSalomeJob** permet de lancer une application Salomé sur un gestionnaire de batch.
122 Cette méthode retourne un identifiant de **job** qui est utilisé dans les méthodes **queryJob**,
123 **deleteJob** et **getResultsJob**.
125 Voici un exemple d'utilisation de cette méthode:
135 clt = orbmodule.client()
136 cm = clt.Resolve('SalomeLauncher')
138 # Le script python qui va être lancé sur le clusteur
139 script = '/home/user/Dev/Install/BATCH_EXEMPLES_INSTALL/tests/test_Ex_Basic.py'
141 # Préparation des arguments pour submitSalomeJob
143 filesToImport = ['/home/user/applis/batch_exemples/filename']
144 batch_params = Engines.BatchParameters('', '00:05:00', '', 4)
145 params = Engines.MachineParameters('','clusteur1','','','','',[],'',0,0,1,1,0,'prun','lsf','','',4)
147 # Utilisation de submitSalomeJob
148 jobId = cm.submitSalomeJob(script, filesToExport, filesToImport, batch_params, params)
151 Voici la description des différents arguments de **submitSalomeJob**:
153 - **fileToExecute**: il s'agit du script python qui sera exécuté dans l'application Salomé sur le clusteur.
154 Cet argument contient le chemin du script **sur** la machine locale et **non** sur le clusteur.
155 - **filesToExport**: il s'agit d'une liste de fichiers qui seront copiés dans le répertoire de lancement sur
157 - **filesToImport**: il s'agit d'une liste de fichiers qui seront copiés depuis le clusteur sur la
158 machine utilisateur lors de l'appel à la méthode **getResultsJob**.
159 - **batch_params**: il s'agit d'une structure qui contient des informations qui seront données au gestionnaire
160 de batch. Cette structure est composée de quatre arguments. Le premier argument permettra de donner le nom du
161 répertoire où l'on veut que les fichiers et l'application Salomé soit lancée (actuellement cette fonction n'est pas
162 disponible). Le deuxième argument est le temps demandé. Il est exprimé sous cette forme: hh:mn:se, ex: 01:30:00.
163 Le troisième argument est la mémoire requise. Elle est exprimée sous la forme: 32gb ou encore 512mb. Enfin,
164 le dernier argument décrit le nombre de processeurs demandé.
165 - **params**: il contient la description de la machine souhaitée. Ici on identifie clairement sur quel clusteur
166 on veut lancer l'application.
168 Pour connaitre dans quel état est le Job, il faut utiliser la méthode **queryJob**. Il y a trois états possibles:
169 **en attente**, **en exécution** et **terminé**.
170 Voici un exemple d'utilisation de cette méthode:
174 status = cm.queryJob(jobId, params)
175 print jobId,' ',status
176 while(status != 'DONE'):
177 os.system('sleep 10')
178 status = cm.queryJob(jobId, params)
179 print jobId,' ',status
181 L'identifiant du job fournit par la méthode **submitSalomeJob** est utilisé dans cette méthode ainsi que la
182 structure **params**.
184 Enfin pour récupérer les résultats de l'application, il faut utiliser la méthode **getResultsJob**.
185 Voici un exemple d'utilisation de cette méthode:
188 cm.getResultsJob('/home/user/Results', jobId, params)
190 Le premier argument contient le répertoire où l'utilisateur veut récupérer les résultats. En plus de ceux
191 définis dans la liste **filesToImport**, l'utilisateur reçoit automatiquement les logs de l'application
192 Salomé et des différents containers qui ont été lancés.
194 .. _salome_clusteur_batch:
196 Salomé sur le clusteur batch
197 ----------------------------
199 Salomé ne fournit par pour l'instant un service pour l'installation automatique de la plateforme depuis
200 la machine personnelle de d'utilisateur. Il faut donc que Salomé (KERNEL + des modules) et une application Salomé
201 soient préinstallés sur le clusteur. Dans l'exemple suivit dans cette documentation, l'application est installée dans
202 le répertoire **/home/user/applis/batch_exemples**.
204 Lors du l'utilisation de la méthode **submitSalomeJob**, Salomé crée un répertoire dans $HOME/Batch/**date_du_lancement**.
205 C'est dans ce répertoire que les différents fichiers d'entrées sont copiés.
207 Contraintes de Salomé sur les gestionnaires de batch
208 ----------------------------------------------------
210 Salomé a besoin de certaines fonctionnalités que le gestionnaire de batch doit autoriser pour que le lancement
211 d'applications Salomé soit possible.
213 Salomé lance plusieurs **threads** par processeurs pour chaque serveur CORBA qui est lancé.
214 Certains gestionnaires de batch peuvent limiter le nombre de threads à un nombre trop faible ou encore le gestionnaire
215 de batch peut avoir configurer la taille de pile des threads à un niveau trop haut. Dans notre exemple, la taille
216 de pile des threads est fixée par l'utilisateur dans le champ **userCommands** du fichier CatalogResources.xml.
218 Salomé lance des processus dans la session sur les machines allouées par le gestionnaire de batch.
219 Il faut donc que le gestionnaire de batch l'autorise.
221 Enfin, Salomé est basée sur l'utilisation de bibliothèques dynamiques et sur l'utilisation de la fonction **dlopen**.
222 Il faut que le système le permette.