__**Rappel :**__
<WRAP box round bgreen 70% >  
Les noeuds de soumission de jobs sont :
  * mesoshared.univ-fcomte.fr
  * mesologin1.univ-fcomte.fr
  * mesologin2.univ-fcomte.fr
  * 
</WRAP>


====== Grid Engine ======

SGE est un système batch avec répartition automatique de charge et gestion de files d'attente. SGE permet : 

  * Le partage des ressources
  * La répartition des jobs soumis dans des files d’attente (queues)
  * L'ordonnancement des jobs en fonction des requêtes utilisateur et de la charge des noeuds
  * Le lancement des jobs éligibles sur un ou plusieurs processeurs
  * La mise en attente des jobs restants

{{:sge_cluster.png|}}


En pratique :

  - L’utilisateur soumet un job avec des paramètres spécifiques
  - Le système de batch (GE) lancera alors le job dès que les ressources requises par l’utilisateur seront disponibles

====== Définitions ======

<WRAP center round info 60%>
**Queue** : une queue est une file d'attente dans laquelle s'accumulent les jobs en attente de traitement par l'ordonnanceur.

**Job** : une tâche ou job est un petit programme (shell) contenant la définition de l'environnement dans lequel il souhaite lancer son calcul, ainsi que les commandes nécessaires au lancement du traitement.
</WRAP>
 



====== Organisation des files d'attente au Mésocentre======

Suivre ce lien [[queues|]]
====== Soumission de jobs interactifs ======

**Problème** :
  * Ouvrir un shell sur un noeud particulier. Utile pour la compilation et le post-traitement par exemple.
  * Lancer une programme directement sur un nœud de calcul en mode interactif


** Solution ** : 
  - ''qlogin'' pour se connecter sur un noeud de calcul en mode interactif
  - ''qrsh'' pour lancer directement un programme sur un noeud en mode interactif  
 
** Exemple 1 ** :

<code bash>
[user@mesologin1~]$ qlogin

[user@node1-13 ~]
</code>

il est possible de quitter ce mode interactif à l'aide de la commande ''exit'' ou du raccourci clavier ''CTRL-D''

** Exemple 2 ** : se connecter à un noeud particulier (**utilise la queue par défaut : all.q**)

<code bash>
[user@mesologin1 ~]$ qlogin -l hostname=node1-20

</code>

** Exemple 2.1 ** : se connecter à un noeud particulier d'une queue donnée, par exemple on se connecte sur les machines de la queue **tesla.q** ou **bigmem**
 
<code bash>
[user@mesologin1 ~] qlogin  -q tesla.q

</code>

**Exemple 3 ** : demander un noeud avec 16 coeurs pendant 8h 
<code bash>
[user@mesologin1 ~] qlogin  -q all.q -pe openmp 16 -l h_rt=8:00:00
</code>

**Exemple 4** : lancer un programme directement sur le noeud GPU (CTL +C) pour l'arrêter.

<code bash>
$ qrsh -q tesla.q  PGI_ACC_TIME=1 ./acc_mm.pgi.exe
</code>
====== Soumission passive de jobs (mode batch) ======

Pour lancer des jobs de manière asynchrone,
c'est à dire sans avoir besoin d'attendre la fin de l'exécution du calcul,
il est nécessaire d'utiliser la commande ''qsub''.

Une aide exhaustive est disponible à l'aide de la commande suivante :

<code bash>
$ qsub -help
$ man qsub
</code>

Généralement :

<code bash>
$ qsub [options] [scriptfile]
</code>

Où **options** correspond aux ressources demandées, par exemple:

  * file d'attente
  * mémoire
  * nombre de nœuds
  * temps d'exécution
  * ...
 
et **scriptfile** représente le script de lancement de l'application

<note tip>Toute ces options peuvent être également intégrées dans le script, de manière à être appliquée à toute utilisation du script de soumission.</note>

===== Options principales de SGE =====


^ Option        ^ Description          ^ 
|''#$ -q [queue]''| Queue (file d'attente) à utiliser |
|''#$ -N [job]''| Nom du job |
|''#$ -V ''| Exporte toutes les variables d'environnement |
|''#$ -cwd'' | Utiliser le répertoire courant comme répertoire de travail |
|''#$ -o [outfile]''| Nom du fichier où stocker la sortie standard |
|''#$ -e [errfile]''| Nom du fichier où stocker les erreurs |
|''#$ -pe [par]''| Environnement parallèle à utiliser |
===== Variables d'environnement =====

Dans le script SGE, on peut utiliser les variables d'environnement suivantes :

^ Variable        ^ Description          ^ 
| ''$JOB_ID''| Identifiant unique propre au job   | 
| ''$JOB_NAME''| Nom attribué au job (par défaut, correspond au nom du script) |
| ''$TMPDIR''| Répertoire temporaire de SGE, supprimé à la fin de l'exécution du job |
| ''$SGE_TASK_ID''| Identificant de la tâche courante en cas d'utilisation de tableaux de tâches (CF. Job parallèle)|
| ''$NSLOTS''| Nombre de cœurs demandés par le script (Voir Job parallèle)|

===== Soumission d'un job séquentiel =====

<note note>** Un job séquentiel s'exécute sur un et un seul cœur d'un nœud particulier **</note>

{{ :sge_1c.png }}

Exemple de script :

<file bash script.sge>
#!/bin/bash
#$ -V
#$ -N test_sge
#$ -cwd
#$ -o $JOB_NAME.$JOB_ID.out
#$ -e $JOB_NAME.$JOB_ID.err



pwd
sleep 30
</file>

un autre exemple :

<file bash script.sge>
#!/bin/bash
#$ -V
#$ -N test_sge
#$ -cwd
#$ -o $JOB_NAME.$JOB_ID.out
#$ -e $JOB_NAME.$JOB_ID.err


time ./monProgrammeCompile
</file>


Soumission du job :

<code bash>$ qsub script.sge</code>

Visualisation de l'état :

<code bash>
$ qstat
job-ID  prior   name       user         state submit/start at     queue                          slots ja-task-ID 
-----------------------------------------------------------------------------------------------------------------
  90312 0.74999 test_sge   Username    r     07/01/2010 14:38:21 all.q@node1-31               1  
</code>


===== Soumission d'un job parallèle =====

<note>**Un job parallèle s'exécute sur plusieurs coeurs**</note>

{{ :sge_dm.png }}

==== Tableau de tâches ====

**Problème** : lancer plusieurs instances du même programme en parallèle sur des données différentes

 **Exemple applicatif **: lancer l'application ''appli'' 100 fois en parallèle avec des données différentes : ''input1'',''...'' ''input100''.
 L'application produira des données ''output1'', ''...'', ''output100''
 
**Solution** : utilisation de tableau tâches (Technique SGE)

{{ :task.png?600 |}}

**Syntaxe ** : 
<code bash>#$ -t 1-100 </code>

On peut fixer le nombre de tâches actives à un instant donné avec l'option <code bash>#$ -tc </code>

Exemple 100 tâches à exécuter avec un pool de 50 :

<code bash>#$ -t 1-100 -tc 50 </code>


** Script pour l'exemple applicatif **:

<file bash script_array.sge>
#!/bin/bash 
#$ -q all.q
#$ -N test_sge
#$ -t 1-100 
#$ -o $JOB_NAME.$JOB_ID.out
#$ -o $JOB_NAME.$JOB_ID.err
#$ -l h_vmem=4G
  
./appli input$SGE_TASK_ID output$SGE_TASK_ID

</file> 

==== Application parallèle openMP (mémoire partagée) ====

**Contexte** : l'application s'exécute sur un nœud en utilisant plusieurs cœurs

**Solution** : utilisation l'environnement parallèle ''openmp''

<code bash>
#$ -pe openmp <nbSlots>
export OMP_NUM_THREADS=$NSLOTS
</code>

**Exemple**

<file bash script_openmp.sge>
#!/bin/bash
#$ -N test_sge
#$ -pe openmp 8  ## on demande 8 coeurs 
#$ -o $JOB_NAME.$JOB_ID.out

export OMP_NUM_THREADS=$NSLOTS

## lancement de l'application 

./appli input
</file>


==== Application parallèle MPI (mémoire distribuée) ====

  * **Contexte** : on demande plusieurs coeurs sur plusieurs noeuds 
  * Utilisation de l'environnement parallèle ''mpi''
  * Utilisation de la file d'attente ''parallel.q'' 


**Exemple d'un script SGE MPI**

<file bash script_mpi.sge>
#!/bin/bash 
#$ -q parallel.q
#$ -pe mpi 16
#$ -N test_sge
#$ -o $JOB_NAME.$JOB_ID.out
#$ -e $JOB_NAME.$JOB_ID.err

#### on charge le module open mpi

module load mpi/openmpi/icc/1.7.5

## lancement de l'application
mpirun -np $NSLOTS ./appli_mpi   
</file>

======= Suivi des jobs =======
====== Notification par Mail ======

SGE peut notifier l'utilisateur lorsque le job est démarré, arrêté ou supprimé. Pour cela il faut rajouter certaines options dans vos scripts :

  - Spécifier l’adresse Mail de réception des messages SGE ''#$ -M addresse@mail''
  - Spécifier le type de notification :
     * recevoir un mail en fin d'exécution du job ''#$ -m e''
     * recevoir un mail en début d'exécution du job ''#$ -m b ''
     * recevoir un mail lorsque le job est interrompu '' #$- m a''

<note tip>Il est possible de combiner les types de notifications :  ''#$ -m bea''</note>

**Exemple**
<code bash>
#!/bin/bash 

#$ -N test_sge
#$ -o $JOB_NAME.$JOB_ID.out
 
#$ -M kamel.mazouzi@univ-fcomte.fr
#$ -m bea  ##notification : debut, arret, fin
 
sleep 60

</code>

====== Quelques commandes utiles ======

Pour lister les jobs  

<code bash>
$ qstat
</code>

Afficher la liste de tous les jobs
<code bash>
$ qstat -u "*" 
</code>

Affichier la liste des noeuds exécutant mes jobs
<code bash>
$ qstat -g t
</code>

Afficher l'état des instances des queues

<code bash>
$ qstat -f 
</code>


Afficher l'utilisation des queues
<code bash>
$ qstat -g c

CLUSTER QUEUE                   CQLOAD   USED    RES  AVAIL  TOTAL aoACDS  cdsuE  
--------------------------------------------------------------------------------
3dvisu.q                          0.01      0      0      8      8      0      0 
all.q                             0.00      0      0    508    508      0      0 
parallel.q                        0.00      0      0    704    704      0      0 
tesla.q                           0.00      0      0      8      8      0      0 
xphi.q                            0.01      0      0     12     12      0      0 

</code>

Afficher les jobs en **attente** pour l'utilisateur toto 
<code bash>
$ qstat -u toto -s p
</code>


Afficher les jobs en **exécution** pour l'utilisateur toto 
<code bash>
$ qstat -u toto -s r
</code>

Afficher l'état d'un job en erreur (la ligne error peut indiquer la raison de non soumission si le job est en mode **Eqw**) 
<code bash>
$ qstat -j 66666
</code>

Savoir pourquoi un job n'a pas ete schedule
<code bash>
$ qstat -j job_id
</code>

Afficher les jobs terminés (historique)
<code bash>
$ qstat -s z
</code>

Afficher les ressources disponibles 
<code bash>$ qhost</code>

Afficher les ressources disponibles en détail ( mémoire, swap, jobs, ...) 
<code bash>$ qhost -q</code>

====== Suppression de jobs  ======

Supprimer un job 

<code bash>
$ qdel 666 ## supprime le job 666 
</code>

Supprimer tous les jobs de toto
<code bash>
$ qdel -u toto
</code>

Forcer la suppression du job numéro 66666
<code bash>
$ qdel -f 66666
</code>


====== Gestion des jobs  ======

Pour basculer les jobs d'un utilisateur de la file courante vers une nouvelle file (newqueue)

Exemple : basculer les jobs de l'utilisateur ''dupond'' de la file ''all.q'' vers la file ''bigmem.q''

<code bash>
$ qalter -u dupond -q bigmem.q
</code>


Pour suspendre un job :

<code bash>
$ qhold jobid
</code> 

Pour reprendre le traitement d'un job :

<code bash>
$ qrls jobid
</code> 

====== États possible d'un job ======

Après la soumission d'un job, ce dernier peut avoir plusieurs états :

|**d**|	 deleting|
|**t , r**|	transfering, running 	|
|**s , S , T**|	suspending , threshold|
|**R**|	restarted|
|**w**|	waiting|
|**h**|	hold|
|**E**|	error|
|**q**|	queuing|


====== Gestion de la mémoire ======



L'utilisation de l'option **''h_vmem''** est vivement recommandée pour spécifier la mémoire nécessaire à l'exécution des jobs.
Cette pratique permet à votre application de disposer des ressources appropriées (cœurs/mémoire) et d'éviter des crashs liés à l'utilisation
de ressources excessives sur le cluster (saturation d'un ou plusieurs nœuds de calcul).

Il est par conséquent important de préciser la quantité mémoire à prévoir dans vos scripts :

<code bash>
#$-l h_vmem=MEM_MAX
</code>

^ MEM_MAX  | Quantité de mémoire maximale autorisée par cœur/processus|


<note warning>
**ATTENTION : Votre job sera tué par SGE s'il dépasse cette quantité mémoire même d'un seul octet**\\
Si aucune valeur n'est précisée pour ''h_vmem'' dans vos scripts, **une valeur de 1G lui sera attribuée par défaut**.
</note>

<note important>Nous vous invitons a bien spécifier la valeur ''h_vmem'' en évitant **la surestimation** pour ne pas bloquer les autres utilisateurs. \\
Pour savoir la mémoire réellement utilisée par votre application, utiliser les commandes suivantes :<color blue> ''qmem, qmemview'' ou sur le portail https://mesoportail.univ-fcomte.fr rubrique ''mesjobs'' </color>
</note>

===== Exemple d'utilisation =====

<code bash>
qsub -l h_vmem=2G mon_script.sge
</code>

<code bash>
qsub -l h_vmem=1800M mon_script.sge
</code>

Mon job a besoin de 1800 Mo et il sera tué par SGE s'il dépasse cette valeur.

<code bash>
qsub -l h_vmem=400M mon_script.sge
</code>
<note tip>Vous pouvez spécifier une valeur inférieur à la valeur par défaut (2G)</note> 

==== Applications Séquentielles ====
L'application séquentielle s'exécute sur un 1 seul cœur, une valeur h_vmem lui sera attribuée : \\

<code bash>
#$ -l h_vmem=300M
</code>
ou
<code bash>
qsub -l h_vmem=300M script.sge
</code>

==== Applications MPI ====

La quantité mémoire demandée est par **processus** ou par **cœur**. Si une application parallèle s'exécutant sur : ''NOMBRE_DE_COEURS '' coeurs et a besoin d'une mémoire : ''MEMOIRE_TOTALE'', il faut diviser cette quantité sur l'ensemble de cœeurs :

<code bash>
#$ -l h_vmem= MEMOIRE_TOTALE/NOMBRE_DE_COEURS 
</code>
   
=== Exemple ===

L'application MPI à besoin en total de ''24000 M''

<code bash>
qsub -pe impi_tight=16 -h v_mem=1500M script.sge
</code>


==== Applications OpenMP ====

Dans le cas ou tous les cœurs sont utilisés, il vaut mieux prendre la totalité de la mémoire sur un noeud.

=== Exemple ===
Sur une machine de 12G mémoire :
<code bash>
qsub -pe openmp 8 -l h_vmem=1.5G script.sge
</code> 
 

==== Mode interactif ====

Par exemple :
<code>
$ qlogin -q tesla.q -l h_vmem=2G
</code>

==== Comment connaître les valeurs disponibles ''h_vmem'' sur les noeuds de calcul ? ====

<code bash>
qhost -F h_vmem
</code>

<code>
qmemview
</code>
==== Résumé ==== 

  * La quantité mémoire à spécifier est par **coeur physique**.
  * La valeur par défaut est de **1.5G/coeur**.
  * Vous pouvez ajuster cette valeur selon vos besoins : vous pouvez demander **plus** ou **moins**.
  * Évitez la surestimation, utilisez les commandes : <color blue>qmem, qmemAll, qmemview </color> pour visualiser la mémoire réellement utilisée.
  * En cas de doute, contactez les administrateurs.  

**Visualisation de la mémoire utilisée par différents jobs, la commande : qmemAll**



^JOB ID^^SLOTS^^VMEM REQUESTED^^TOTAL VMEM USED^^RECOMMENDED VMEM VALUE^^RATIO USED^		
|157263||110||<color blue>1100M</color>||63.159G||<color green>705.331M</color>||53.434%|   
|157264||60||<color blue>1000M</color>||19.821G||<color green>405.504M</color>||33.792%|   
|157353||32||<color blue>2.7G</color>||53.173G||<color green>1.993G</color>||61.518%|   
|157385||24||<color blue>1.5G</color>||23.591G||<color green>1206.681M</color>||65.466%|   
|157407||64||<color blue>2.0G</color>||70.971G||<color green>1.329G</color>||55.400% |  
|157409||60||<color blue>1000M</color>||21.235G||<color green>433.766M</color>||36.147%|   
|157462||68||<color blue>1000M</color>||23.149G||<color green>417.792M</color>||34.816%|   
|**158141**||8||<color blue>1.5G</color>||545.871M||<color green>81.879M</color>||<color red>4.442%</color>|

**Analyse**\\

  * La première chose a voir ici est la colonne **RECOMMENDED VMEM VALUE**. En fait, l'outil vous suggère des valeurs approximatives pour vos applications.  
  * On remarque que la plupart des applications **n'utilisent pas toute la mémoire demandée ! **  
  * Le job **158141** utilise la mémoire par défaut attribuée par SGE (1.5G) . Alors que l'utilisateur pouvait donner une valeur inférieur à 1G. Part exemple ''100M'' 
 

====== Choisir le type du processeur à utiliser ======
<note important>
Certains utilisateurs étudient les performances des applications et le temps 'exécution est important dans ce cas. Attention, le cluster n'est pas homogène, il contient 3 types de processeurs (westmere, sandybridge, haswell).</note>


^processeur^ date d'achat ^ vitesse (GHz) ^ puissance (GFlops)/node ^ Nombre de cœurs^nombre de nœuds ^remarque^
|Westmere| 2010| 2.66GHz | 255  | 12 | x | utiliser dans la file d'attente ''all.q''| 
|Sandybridge| 2013| 2.2GHz | 281  | 16 | x | utiliser dans la file d'attente ''all.q'' et parallel.q|
|Haswell| 2015| 2.6GHz | 665 | 16 | 20 | utiliser dans la file d'attente  parallel.q|
   

Pour demander à utiliser un type de processeur particulier ;

<code bash>
#$ -l proctype=XXXX
</code>

Avec XXXX=''westmere'', ''sandybridge'' ou ''haswell''.

Ainsi, pour s'exécuter sur le processeur ''sandybridge'', l'option SGE est : 

<code bash>

#$ -l proctype=sandybridge
</code>

<note warning>Le processeur Haswell est disponible uniquement pour les applications ''MPI'' de la file ''parallel.q''</note>

**Comment connaître le type de processeur sur un noeud ?**
La commande ''proctype'' permet d'afficher le type d’architecture du processeur :

<code bash>
$ [user@node1-32 ~]$ proctype 
    -march= westmere

</code>