doc/batch.rst

   1
   2 .. _batch:
   3
   4 Lancement d'une application Salomé dans un gestionnaire de Batch
   5 ================================================================
   6
   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.
  13
  14 Principes
  15 ---------
  16
  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.
  22
  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`).
  30
  31 .. _catalogresources_batch:
  32
  33 Description du clusteur par le biais du fichier CatalogResources.xml
  34 --------------------------------------------------------------------
  35
  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.
  39
  40 Voici un exemple de description d'un clusteur:
  41
  42 ::
  43
  44   <machine hostname="clusteur1"
  45            alias="frontal.com"
  46            protocol="ssh"
  47            userName="user"
  48            mode="batch"
  49            batch="lsf"
  50            mpi="prun"
  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"
  55            OS="LINUX"
  56            CPUFreqMHz="2800"
  57            memInMB="4096"
  58            nbOfNodes="101"
  59            nbOfProcPerNode="2"/>
  60
  61 Voici la description des différents champs utilisés dans un lancement batch:
  62
  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.
  79
  80 Il existe deux champs optionnels qui peuvent être utiles selon la configuration des clusteurs:
  81
  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
  84   les noeuds.
  85
  86
  87 .. _service_launcher:
  88
  89 Utilisation du service Launcher
  90 -------------------------------
  91
  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.
  94
  95 Voici son interface:
  96
  97 ::
  98
  99   interface SalomeLauncher
 100   {
 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);
 108
 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);
 111
 112     void getResultsJob( in string directory, in long jobId, in MachineParameters params )
 113          raises (SALOME::SALOME_Exception);
 114
 115     boolean testBatch(in MachineParameters params) raises (SALOME::SALOME_Exception);
 116
 117     void Shutdown();
 118     long getPID();
 119   };
 120
 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**.
 124
 125 Voici un exemple d'utilisation de cette méthode:
 126
 127 ::
 128
 129   # Initialisation
 130   import os
 131   import Engines
 132   import orbmodule
 133   import SALOME
 134
 135   clt = orbmodule.client()
 136   cm  = clt.Resolve('SalomeLauncher')
 137
 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'
 140
 141   # Préparation des arguments pour submitSalomeJob
 142   filesToExport = []
 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)
 146
 147   # Utilisation de submitSalomeJob
 148   jobId = cm.submitSalomeJob(script, filesToExport, filesToImport, batch_params, params)
 149
 150
 151 Voici la description des différents arguments de **submitSalomeJob**:
 152
 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
 156   le clusteur.
 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.
 167
 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:
 171
 172 ::
 173
 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
 180
 181 L'identifiant du job fournit par la méthode **submitSalomeJob** est utilisé dans cette méthode ainsi que la
 182 structure **params**.
 183
 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:
 186 ::
 187
 188   cm.getResultsJob('/home/user/Results', jobId, params)
 189
 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.
 193
 194 .. _salome_clusteur_batch:
 195
 196 Salomé sur le clusteur batch
 197 ----------------------------
 198
 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**.
 203
 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.
 206
 207 Contraintes de Salomé sur les gestionnaires de batch
 208 ----------------------------------------------------
 209
 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.
 212
 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.
 217
 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.
 220
 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.
 223