Outils pour utilisateurs

Outils du site


public:description_de_poincare

Connexion

4 nœuds interactifs sont accessibles via ssh depuis les machines renseignées dans le FTIP complété lors de la demande de création de compte :

ssh login@poincareint[01-04].maisondelasimulation.fr

Pour rappel, le mot de passe initial est constitué du mot de passe transmis par l'IDRIS concaténé avec le mot de passe renseigné dans le FEPC.
Merci de la changer rapidement via un passwd sur poincareint01, le mot de passe sera synchronisé sur les autres nœuds interactifs dans la journée.

Description

Caractéristiques des nœuds

Calculateur IBM, principalement composé de serveurs iDataPlex dx360 M4 :

  • 92 nœuds de calculs “poincare[001-092]” (clallmds dans LoadLeveler) équipés de :
    • 2 processeurs Sandy Bridge E5-2670 (2.60GHz, 8 cœurs par processeur, soit 16 cœurs par nœud)
    • 32 Go de mémoire par nœud
  • 4 nœuds GPU “poincaregpu[01-04]” (clgpu dans LoadLeveler) équipés de :
    • 2 processeurs Sandy Bridge E5-2670
    • 64 Go de mémoire par nœud
    • 2 GPU Tesla K20 (Cuda Capability 3.5, 4.8 Go de mémoire par GPU)
  • 4 frontales interactives “poincareint[01-04]” équipées de :
    • 2 processeurs Sandy Bridge E5-2670
    • 32 Go de mémoire par nœud


Sont également présents sur Poincare :

  • 2 nœuds de calcul “large” x3755 M3 mais non intégrés dans LoadLeveler. Ils sont équipés de :
    • 4 processeurs AMD Opteron 6282 (2.60GHz, 16 cœurs par processeur, soit 64 cœurs par nœud)
    • 128 Go de mémoire par nœud
    • accessibles via ssh “poincarebig[01-02]” depuis les frontales

File System

  • GPFS (“General Parallel File System”) : Partagé par l’ensemble des nœuds
    • /gpfs1l : 7 To, contient les ${HOME} ainsi que l'environnement logiciel partagé
    • /gpfsdata : 37 To, accessible via la variable ${SCRATCHDIR}
  • /tmp : local à chacun des nœuds
    • 200 Mo

Ces systèmes ne sont pas nettoyés automatiquement (si ce n'est lors du reboot d'un nœud pour le /tmp) et aucun système de quota n'est en place.
Aucun de ces systèmes n'est sauvegardé.

InfiniBand

QLogic QDR

OS

L'ensemble de la configuration fonctionne sous le même CentOS 6.5 :

  • un environnement de compilation est disponible en batch
  • un environnement graphique est disponible en batch
  • le driver Nvidia est déployé sur les noeuds GPU et sur les frontales

La seule différence notable concerne l'absence du driver InfiniBand des frontales.

Gestionnaire de tâches/ressources

L'ordonnancement des batchs est gérée par LoadLeveler suivant le principe du 1er arrivé/ 1er servi, un système de backfilling est en place.
La durée maximale d'un job est de 20 heures, le volume de ressources par job n'est pas contraint.
Par défaut, 1 nœud de calcul donné peut être partagé par plusieurs utilisateurs, il conviendra d'être attentif notamment lors de l'exécution de job n'ayant pas un ratio cœur/processus de 1.

POE (Parallel Operating Environment d'IBM) n'est pas déployé sur Poincare pour le moment, la soumission de tous les jobs MPI doit intégrer l'exécution d'un mpirun, des exemples de scripts batch sont présentés plus loin.

Environnement

Par défaut, l'environnement HPC est vide, seuls sont présents les compilateurs GNU 4.4.6 et Python 2.6.6 (sans modules).

Environnement module

La gestion de l'environnement est faite via l'utilisation de module :

  • Liste les softs disponibles :
  module avail
  • Liste les softs intégrés dans l'environnement :
  module list
  • Intègre le soft tool dans l'environnement courant :
  module load tool/version
  • Supprime le soft tool de l'environnement courant :
  module unload tool/version
  • Remplace la version old-version du soft tool par la version new-version dans l'environnement courant :
  module switch tool/old-version tool/new-version
  • Affiche les variables d'environnement modifiées :
  module show tool/version

Attention, la commande module n'est pas persistante. L'exécution d'une commande module ne vaut que pour la durée de la session courante.
Pour intégrer durablement des éléments dans son environnement courant il est nécessaire d'intégrer les commandes modules dans un fichier ~/.bash_profile (ce fichier n'existe pas à la création du compte). Les commandes module init… ne font que parcourir les fichiers de démarrage usuels pour compléter un module load existant. La commande module peut être intégrée dans un script batch pour positionner l'environnement associé à un job. Le fichier ~/.bash_profile est exécuté en pré-exécution des batchs, les modules chargés par défaut et les modules chargés en batch peuvent alors être en conflit.

Pour plus de détails, se référer à man module.

Compilateurs

Outre les compilateurs GNU fournis avec la distribution, sont présents sur Poincare les compilateurs :

  • Intel : 12 et 13
  • GNU : plus récents que les compilateurs natifs
  • CUDA/HMPP/PGI
  • Clang
    • Attention, la version 8.0.0 n'est pas complètement opérationnelle, il est nécessaire de spécifier certains chemin à la compilation.
    • ex : pour un code C++, -I${LLVM_ROOT}/include/c++/v1 -L${LLVM_ROOT}/lib -lc++

Environnement MPI

Sont installées sur Poincare les bibliothèques MPI suivantes :

Par défaut, les wrappers MPI associées à ces bibliothèques s’appuient sur les compilateurs Intel, pour changer de compilateur il est nécessaire de positionner les variables d'environnement comme indiqué ci-dessous.
Ces variables sont positionnées lors du chargement du module associé.

export I_MPI_CC=gcc ; export I_MPI_CXX=icpc ; export I_MPI_F77=g77 ; export I_MPI_F90=gfortran
[poincareint03:~]$ module list
Currently Loaded Modulefiles:
  1) intel/12.1.0     2) intelmpi/4.0.3
[poincareint03:~]$ echo $I_MPI_CC
icc
[poincareint03:~]$ mpicc -v
mpiicc for the Intel(R) MPI Library 4.0 Update 3 for Linux*
Copyright(C) 2003-2011, Intel Corporation.  All rights reserved.
icc version 12.1.0 (gcc version 4.4.6 compatibility)
[poincareint03:~]$ export I_MPI_CC=gcc
[poincareint03:~]$ mpicc -v
mpigcc for the Intel(R) MPI Library 4.0 Update 3 for Linux*
Copyright(C) 2003-2011, Intel Corporation.  All rights reserved.
Utilisation des specs internes.
Target: x86_64-redhat-linux
Configuré avec: ../configure --prefix=/usr --mandir=/usr/share/man --infodir=/usr/share/info --with-bugurl=http://bugzilla.redhat.com/bugzilla --enable-bootstrap --enable-shared --enable-threads=posix
--enable-checking=release --with-system-zlib --enable-__cxa_atexit --disable-libunwind-exceptions --enable-gnu-unique-object --enable-languages=c,c++,objc,obj-c++,java,fortran,ada --enable-java-awt=gtk
--disable-dssi --with-java-home=/usr/lib/jvm/java-1.5.0-gcj-1.5.0.0/jre --enable-libgcj-multifile --enable-java-maintainer-mode --with-ecj-jar=/usr/share/java/eclipse-ecj.jar --disable-libjava-multilib
--with-ppl --with-cloog --with-tune=generic --with-arch_32=i686 --build=x86_64-redhat-linux
Modèle de thread: posix
gcc version 4.4.6 20110731 (Red Hat 4.4.6-3) (GCC) 

Ou :

export OMPI_CC=gcc ; export OMPI_CXX=g++ ; export OMPI_F77=g77 ; export OMPI_F90=gfortran
[poincareint03:~]$ module switch intelmpi openmpi
Using intel compiler to configure intelmpi wrappers...
(switch1) intelmpi version 4.0.3
(switch2) openmpi version 1.6.3
Using intel compiler to configure intelmpi wrappers...
(switch3) intelmpi version 4.0.3
[poincareint03:~]$ mpicc -v
icc version 12.1.0 (gcc version 4.4.6 compatibility)
[poincareint03:~]$ mpicc --show
icc -I/gpfslocal/pub/openmpi-1.6.3/include -pthread -L/gpfslocal/pub/local/lib64 -L/gpfslocal/pub/openmpi-1.6.3/lib -lmpi -ldl -lm -Wl,--export-dynamic -lrt -lnsl -linfinipath -lutil -lm -ldl
[poincareint03:~]$ echo $OMPI_CC
icc
[poincareint03:~]$ export OMPI_CC=gcc
[poincareint03:~]$ mpicc --show
gcc -I/gpfslocal/pub/openmpi-1.6.3/include -pthread -L/gpfslocal/pub/local/lib64 -L/gpfslocal/pub/openmpi-1.6.3/lib -lmpi -ldl -lm -Wl,--export-dynamic -lrt -lnsl -linfinipath -lutil -lm -ldl
Ceci est indépendant du compilateur utilisé lors de la compilation des bibliothèques MPI.

Attention pour OpenMPI, à compter de la version 3, le gestionnaire de ressource n'étant plus pris en charge correctement, l'exécution multi-noeuds des jobs doit passer par l'utilisation de l'option -host :

 mpirun -host `echo $LOADL_PROCESSOR_LIST|sed -e "s/fr\ /fr,/g"` -report-bindings hostname

La bibliothèque mvapich2 a également été mise à disposition. Comme pour OpenMPI-3, cette bibliothèque n'est pas couplée avec LoadLeveler, la soumission de jobs multi-noeuds est prise en charge via

 mpirun -hosts `echo $LOADL_PROCESSOR_LIST|sed -e "s/fr\ /fr,/g"` hostname

L'affinité est gérée par variable d'environnement :

$ export OMP_NUM_THREADS=8
$ export MV2_CPU_BINDING_LEVEL=socket
$ export MV2_CPU_BINDING_POLICY=scatter
$ mpirun -hosts `echo $LOADL_PROCESSOR_LIST|sed -e "s/fr /fr,/g"` -np 16 -ppn 2 ./a.out
$ export OMP_NUM_THREADS=4
$ export MV2_CPU_MAPPING=0-3:4-7:8-11:12-15
$ mpirun -hosts `echo $LOADL_PROCESSOR_LIST|sed -e "s/fr /fr,/g"` -np 16 -ppn 4 ./a.out

Pour plus d'infos, la doc avec un focus sur le mapping.

Comme pour les autres bibliothèques le compilateur embarqué peut être surchargé :

$ mpicxx --version | head -n 1 
g++ (GCC) 4.8.4
$ export MPICH_CXX=clang++
$ mpicxx --version | head -n 1 
clang version 8.0.0 (https://git.llvm.org/git/clang.git/ ebdd117a2308d58b31404cbd02877c70772f0cec) (https://git.llvm.org/git/llvm.git/ 9f32dc98ef899a8c57cf8f7b6a2efab0302ad106)

BLAS/LAPACK/ScaLAPACK

Les bibliothèques BLAS, LAPACK et ScaLAPACK sont disponibles via la bibliothèque MKL fournie par Intel.
Exemples d'édition de liens avec ScaLAPACK après module load mkl/11.0 :

  • Avec IntelMPI :
  -L$(MKLROOT)/lib/intel64 -lmkl_scalapack_lp64 -lmkl_intel_lp64 -lmkl_sequential -lmkl_core -lmkl_blacs_intelmpi_lp64 -lpthread -lm 
  • Avec OpenMPI :
  -L$(MKLROOT)/lib/intel64 -lmkl_scalapack_lp64 -lmkl_intel_lp64 -lmkl_sequential -lmkl_core -lmkl_blacs_openmpi_lp64 -lpthread -lm 

Pour plus d'options, se référer à Intel® Math Kernel Library Link Line Advisor.

La MKL fonctionne que le code soit compilé en Intel ou en GNU.

L'édition de liens avec les compilateurs Intel est simplifiée au moyen de l'option -mkl. Par défaut, la version séquentielle est utilisée.Pour plus de détails, se référer aux manuels de référence.

La bibliothèque ATLAS est également disponible après module load atlas/3.10.1 :

  -L${ATLAS_LIB_DIR}  -llapack -lf77blas -lcblas -latlas -lgfortran 

Python

Certains modules Python usuels sont disponibles via Enthought Python Distribution (module load python/epd).

X11 en batch

Exécuter le script ci-dessous avant la soumissions du job :

/gpfslocal/pub/local/tools/export_DISPLAY.sh

LoadLeveler

L'exécution des tâches et les ressources sont gérées par LoadLeveler :

Du bon usage de Poincare

Poincaré est une machine de développement permettant de mettre au point de nouveaux codes de simulations avant de les exploiter sur les centres de calcul nationaux.
Pour permettre à chacun de tester et ajuster ses développement dans des temps acceptables proche d'un usage interactif,
merci de modérer les demandes de ressources (nombre de nœuds x temps demandé) entre 07h30 et 19h30.
Pour des usages se rapprochant de runs de production, merci de spécifier la directive de soumission : #@ startdate = 19:30.
Dans ces conditions, les jobs concernés démarreront dès que les ressources seront disponibles après 19h30.

Pour rappel, pour des usages intensifs il est recommandé de formuler des demandes d'heures auprès de GENCI ou PRACE.

Les commandes usuelles

  • Ressources à disposition : llclass
  [poincareint03:~]$ llclass
  Name                 MaxJobCPU     MaxProcCPU  Free   Max Description          
                      d+hh:mm:ss     d+hh:mm:ss Slots Slots                      
  --------------- -------------- -------------- ----- ----- ---------------------
  compil               undefined      undefined    24    24                      
  clallmds             unlimited      unlimited  1472  1472                      
  clgpu                unlimited      unlimited    48    48  

Attention, les valeurs retournées par llclass sont incomplètes, seules les tâches MPI au sens LoadLeveler ( #@ total_tasks) apparaissent. La durée maximale d'un job est de 20 heures, le volume de ressources par job n'est pas contraint.

  • Ressources à disposition : llinfo.py, llinfo_res.py
   [poincareint03:~]$ llinfo.py
   ====================== CLALLMDS ======================
   Run     :  0 	/ 92 	: poincare[]
   Idle    :  76 	/ 92 	: poincare[002-005,007-008,010,012-035,037-047,049-052,054-059,061,063-066,068-071,074-077,079-084,087-090,092]
   Down    :  0 	/ 92 	: poincare[]
   Busy    :  16 	/ 92 	: poincare[001,006,009,011,036,048,053,060,062,067,072-073,078,085-086,091]
   Drained :  0 	/ 92 	: poincare[]
   Draing  :  0 	/ 92 	: poincare[]
   ======================= CLGPU ========================
   Run     :  0 	/ 4 	: poincaregpu[]
   Idle    :  4 	/ 4 	: poincaregpu[01-04]
   Down    :  0 	/ 4 	: poincaregpu[]
   Busy    :  0 	/ 4 	: poincaregpu[]
   Drained :  0 	/ 4 	: poincaregpu[]
   Draing  :  0 	/ 4 	: poincaregpu[]
  • Soumission : llsubmit batch.sh avec batch.sh :

Ce script vaut pour un job pur MPI qui occupe l'intégralité des ressources réservées.

  [poincareint03:~]$ cat batch.sh
  #!/bin/bash
  #@ class            = clallmds                   # clallmds or clgpu
  #@ job_name         = RUN_01                     # Job Name
  #@ total_tasks      = 32                         # Number of MPI ranks
  #@ node             = 2                          # Number of nodes
  #@ wall_clock_limit = 20:00:00                   # Amount or required time HH:MM:SS (Max = 20:00:00)
  #@ output           = $(job_name).$(jobid).log   # Job standard output written in a file named job_name.jobid.log
  #@ error            = $(job_name).$(jobid).err   # Job standard error written in a file named job_name.jobid.err
  #@ job_type         = mpich                      # mpich or serial, mpich = parallel configuration supported on Poincare
  #@ environment      = COPY_ALL                   # export interactive environment in the batch session
  #@ queue                                         # Last keyword for Load leveler, notify effective job submission
  #
  module load intel intelmpi
  mpirun ./a.out
  [poincareint03:~]$ llsubmit batch.sh
  llsubmit: The job "poincareint01-adm.maisondelasimulation.fr.145" has been submitted.
Les commentaires présents dans cet exemple, comme dans ceux qui suivent, perturbe le comportement de LoadLeveler, ces scripts n'ont pas vocation a être utilisés directement sur Poincare.
  • Statut des jobs en machines : llq

Pour plus d'information sur un job en machine donné :

  [poincareint03:~]$ llq -l -j JOBID
  • Suppression d'un job : llcancel
  [poincareint03:~]$ llcancel JOBID

Exemple de scripts

Les scripts présentés ci-dessous sont valables pour les nœuds équipés de 16 cœurs.

IntelMPI

Par défaut, IntelMPI gère l'affinité en fonction du nombre de tâches MPI présentes par nœud :

  • 16 processus MPI par nœud → Cpus_allowed_list: 0
  • 8 processus MPI par nœud → Cpus_allowed_list: 2-3
  • 4 processus MPI par nœud → Cpus_allowed_list: 12-15
  • 1 processus MPI par nœud → Cpus_allowed_list: 0-15
MPI

Cas d'un job pur MPI qui occupe l'intégralité des ressources réservées :

[poincareint03:~]$ cat batch.sh
#!/bin/bash
#@ class            = clallmds
#@ job_name         = RUN_01
#@ total_tasks      = 32
#@ node             = 2
#@ wall_clock_limit = 20:00:00
#@ output           = $(job_name).$(jobid).log
#@ error            = $(job_name).$(jobid).err
#@ job_type         = mpich
#@ queue
#
module load intel intelmpi
mpirun ./a.out

Cas d'un job pur MPI avec nœuds dépeuplés (occupation mémoire supérieure à 2 Go par processus MPI) :

[poincareint03:~]$ cat batch.sh
#!/bin/bash
#@ class            = clallmds+
#@ job_name         = RUN_01
#@ total_tasks      = 16                         # Nombre de processus MPI
#@ node             = 2                          # Nombre de nœuds sur lesquels sont distribués les processus MPI
#@ as_limit         = 3.5gb                      # Limite mémoire pour 8 processus MPI par noeud 
#@ node_usage       = not_shared                 # Obligatoire : En l'absence de cette option, LoadLeveler considère que dans cette configuration des ressources sont libres,
#                                                #               elles pourraient alors être attribuées à un autre job
#@ wall_clock_limit = 20:00:00
#@ output           = $(job_name).$(jobid).log
#@ error            = $(job_name).$(jobid).err
#@ job_type         = mpich
#@ queue
#
module load intel intelmpi
export TASKS_PER_NODE=`echo $LOADL_PROCESSOR_LIST|sed -e s/" "/\\n/g|uniq|wc -l`
mpirun -np ${LOADL_TOTAL_TASKS} -ppn ${TASKS_PER_NODE} -print-rank-map ./a.out
Les commentaires présents dans cet exemple, comme dans ceux qui suivent, perturbe le comportement de LoadLeveler, ces scripts n'ont pas vocation a être utilisés directement sur Poincare.
MPI/OpenMP

Le script présenté dans le cas d'un job pur MPI avec nœuds dépeuplés fonctionne. Par défaut le nombre de threads générés est égal à :

16/${TASKS_PER_NODE}, avec 16 le nombre de cœurs par nœud 

OpenMPI

Par défaut, aucune affinité n'est positionnée dans l'environnement OpenMPI de Poincare.

  • Cpus_allowed_list: 0-15

L'affinité est gérée via les options suivantes du lanceur OpenMPI :

  • -bycore -bind-to-coreCpus_allowed_list: 1
  • -bysocket -bind-to-socketCpus_allowed_list: 0-7
  • -bind-to-noneCpus_allowed_list: 0-15
MPI

Cas d'un job pur MPI qui occupe l'intégralité des ressources réservées :

[poincareint03:~]$ cat batch.sh
#!/bin/bash
#@ class            = clallmds
#@ job_name         = RUN_01
#@ total_tasks      = 32
#@ node             = 2
#@ wall_clock_limit = 20:00:00
#@ output           = $(job_name).$(jobid).log
#@ error            = $(job_name).$(jobid).err
#@ job_type         = mpich
#@ environment      = COPY_ALL 
#@ queue
#
module load intel openmpi
mpirun ./a.out

Cas d'un job pur MPI avec nœuds dépeuplés (occupation mémoire supérieure à 2 Go par processus MPI) :

[poincareint03:~]$ cat batch.sh
#!/bin/bash
#@ class            = clallmds+
#@ job_name         = RUN_01
#@ total_tasks      = 16                         # Nombre de processus MPI
#@ node             = 2                          # Nombre de nœuds sur lesquels sont distribués les processus MPI
#@ as_limit         = 3.5gb                      # Limite mémoire pour 8 processus MPI par noeud 
#@ node_usage       = not_shared                 # Obligatoire : En l'absence de cette option, LoadLeveler considère que dans cette configuration des ressources sont libres,
#                                                #               elles pourraient alors être attribuées à un autre job
#@ wall_clock_limit = 20:00:00
#@ output           = $(job_name).$(jobid).log
#@ error            = $(job_name).$(jobid).err
#@ job_type         = mpich
#@ environment      = COPY_ALL 
#@ queue
#
module load intel openmpi
mpirun -bysocket -bind-to-socket -report-bindings ./a.out
MPI/OpenMP

Par défaut, le nombre de threads généré est associé à l'affinité positionnée. Pour modifier cette valeur sur l'ensemble des nœuds de la réservation il est nécessaire de propager OMP_NUM_THREADS sur tous les nœuds en utilisant l'option -x du lanceur OpenMPI.

[poincareint03:~]$ cat batch.sh
#!/bin/bash
#@ class            = clallmds+
#@ job_name         = RUN_01
#@ total_tasks      = 16                         # Nombre de processus MPI
#@ node             = 4                          # Nombre de nœuds sur lesquels sont distribués les processus MPI
#@ as_limit         = 7gb                        # Limite mémoire pour 8 processus MPI par noeud 
#@ node_usage       = not_shared                 # Obligatoire : En l'absence de cette option, LoadLeveler considère que dans cette configuration des ressources sont libres,
#                                                #               elles pourraient alors être attribuées à un autre job
#@ wall_clock_limit = 20:00:00
#@ output           = $(job_name).$(jobid).log
#@ error            = $(job_name).$(jobid).err
#@ job_type         = mpich
#@ environment      = COPY_ALL 
#@ queue
#
module load intel openmpi
export OMP_NUM_THREADS=4  
mpirun -x OMP_NUM_THREADS -bysocket -bind-to-socket -report-bindings ./a.out

Mode interactif

La commande llinteractif permet de travailler dans des sessions batch interactives en précisant le nombre de nœuds, la classe (clallmds/clgpu) et le nombre d'heures :

[jderouillat@poincareint01:~]$ llinteractif 
Usage : llinteractif number_of_nodes class time_in_hour
[jderouillat@poincareint01:~]$ llinteractif 2 clallmds 2
[jderouillat@poincare001-adm:/gpfshome/mds/staff/jderouillat]$ llq
Id                       Owner      Submitted   ST PRI Class        Running On 
------------------------ ---------- ----------- -- --- ------------ -----------
...
poincareint01-adm.4110.0 jderouilla  6/1  11:04 R  50  clallmds     poincare001-adm
...

[jderouillat@poincare001-adm:/gpfshome/mds/staff/jderouillat]$ hostname 
poincare001-adm
[jderouillat@poincare001-adm:/gpfshome/mds/staff/jderouillat]$ llnodes.py  poincareint01-adm.4110.0
poincareint01-adm.4110.0  :  2 -  poincare[001-002] 
Cette utilisation nécessite la présence d'une clé ssh locale associée au compte sans passphrase.
[poincareint01:~]$ ssh-keygen -t rsa
...
[poincareint01:~]$ touch .ssh/authorized_keys
[poincareint01:~]$ cat .ssh/id_rsa.pub >> .ssh/authorized_keys

Pour une utilisation plus spécifique : En reprenant les mêmes entêtes de script de soumission que ceux décrits plus haut, il est possible de disposer de session interactive sur les nœuds de Poincare via la commmande llrun. L'environnement du shell courant est alors hérité :

[poincareint01:~/POINCARE_TOOLS]$ cat interactive_session.sh 
#!/bin/bash
#@ class            = clallmds
#@ job_name         = temp
#@ total_tasks      = 16
#@ node             = 2
#@ node_usage       = not_shared
#@ wall_clock_limit = 00:30:00
#@ job_type         = mpich
#@ environment      = COPY_ALL 
#@ queue
[poincareint01:~/POINCARE_TOOLS]$ module li
Currently Loaded Modulefiles:
  1) intel/13.0.1                2) openmpi/1.6.3               3) hdf5/1.8.10_intel_openmpi
[poincareint01:~/POINCARE_TOOLS]$ llrun -f interactive_session.sh 
[poincare009:/gpfshome/mds/staff/jderouillat/POINCARE_TOOLS]$ module li
Currently Loaded Modulefiles:
 1) intel/13.0.1               2) openmpi/1.6.3              3) hdf5/1.8.10_intel_openmpi 
[poincare009:/gpfshome/mds/staff/jderouillat/POINCARE_TOOLS]$ mpirun ./a.out 
Process MPI    0/  16 run on  poincare009
Process MPI    6/  16 run on  poincare009
Process MPI    7/  16 run on  poincare009
Process MPI    1/  16 run on  poincare009
Process MPI    2/  16 run on  poincare009
Process MPI    3/  16 run on  poincare009
Process MPI    4/  16 run on  poincare009
Process MPI    5/  16 run on  poincare009
Process MPI   10/  16 run on  poincare055
Process MPI   11/  16 run on  poincare055
Process MPI   12/  16 run on  poincare055
Process MPI   13/  16 run on  poincare055
Process MPI   14/  16 run on  poincare055
Process MPI   15/  16 run on  poincare055
Process MPI    8/  16 run on  poincare055
Process MPI    9/  16 run on  poincare055
[poincare009:/gpfshome/mds/staff/jderouillat/POINCARE_TOOLS]$ logout
Connection to poincare009-adm.maisondelasimulation.fr closed.

En ligne de commande :

[poincareint01:~/POINCARE_TOOLS]$ llrun -k class=clallmds job_name=temp total_tasks=16 node=2 node_usage=not_shared wall_clock_limit=00:30:00 job_type=mpich environment=COPY_ALL 
[poincare009:/gpfshome/mds/staff/jderouillat/POINCARE_TOOLS]$ 
public/description_de_poincare.txt · Dernière modification: 2019/01/08 16:36 par julien.derouillat@cea.fr