christophe.pera <christophe.pera@univ-lyon1.fr>

Version: 1.0

Version Date: 10-02-2021

Version Notes: Version initial de "Manuel utilisateur pour débuter au centre de calcul"

Charte d’utilisation

Les utilisateurs du centre de calcul doivent respecter la charte informatique des utilisateurs de l’Université Claude Bernard Lyon 1. https://www.univ-lyon1.fr/charte-informatique

1. Rappel des points essentiels de la charte.

  • L’utilisateur doit respecter la propriété intellectuelle, les contenus à caractère confidentiel et la vie privée.

  • Le ou la responsable du système d’information de l’université (RSSI) et les administrateurs du SI ont accès à l’ensemble des données techniques pour assurer leurs missions mais s’engagent à respecter les règles de confidentialité.

  • Tout manquement aux règles de la présente Charte est susceptible d’engager la responsabilité de l’utilisateur. Ils doivent également se conformer à la charte RENATER 1 (le réseau de l’UCBL étant raccordé à Internet via le réseau national RENATER) et à la Politique de Sécurité du Système d’Information 2 (PSSI) de l’Université.

A noter:
  • Nous assurons la sécurité sur les comptes et les machines pour cloisonner les environnements utilisateurs par défaut sur les systèmes d’exploitation Linux (CentOS 6 et CentOS 7 pour la prochaine mise à jour) des serveurs de calcul.

  • Un cryptage peut aussi être mis en place comme solution pour protéger vos comptes si vous voulez augmenter le niveau de protection de vos codes.

2. Ressources de calcul et de stockage.

Le centre de calcul donne accès à différentes ressources de calcul financées par différents projets (CPER, ANR, PPR UCBL). Les ressources suivantes sont ouvertes aux chercheurs de la région lyonnaise.

Attention:
  • Jusqu’au 15/06/2021, une partie des ressources migre vers un nouveau système d’exploitation (Clone RHEL 8/ Slurm 20.11.7).

Table 1. Ressources de calcul (certaines sont indisponible jusqu’au 15/06/2021 pour deploiement ou upgrade)
status dispo 15/06/2021 dispo 15/06/2021 dispo 15/06/2021 en ligne upgrade en ligne

constructeur

C6000

C6425

R740xd

C8220

C6000

supermicro

processeur

Intel skylake

AMD 7702 2GHz,256Mo

Intel skylake

Intel E5-2670

Intel 6226 2,9GHz

intel haswell

sockets

2

2

2/4

2

2

2

cœurs

16

64

12/16

8

8/12/24

8

mémoire Go[/]MHz

196

512/3200

196

64/128

128/256

256

disque

GPU

A100/C6000/RTX3090

K20m/K80

réseau

10g/IB FDR

10g

10g

1G/IB FDR

1G/IB FDR

IB FDR

Nbres serveurs

26

10

8

198

48

10

Noms serveurs

node301/530

node200-230

node480-489

Partition SLURM

intel-10g

amd-10g

gpu-10g

parallel

intel-IB-EDR

parallel-gpu

Table 2. Ressource de stockage disponible au 15/06/2021
Nom du serveur Montage/accès Système de fichier Capacité Accès Réseau Débit backup quota Droit localité

P2chpd-storage6

/home_nfs

NFS V4

200To

10G/1G

7 Mo/s

oui

oui

ouvert

p2chpd

mds/oss1/oss2

/scratch

lustre V3

40To

50G

20 Mo/s

non

oui

ouvert

p2chpd:parallel

archive-irods

cli IRODS

IRODS

>650To

10G

14 Mo/s

oui

oui

privé

ccin2p3/p2chpd

autres

divers

nfs V4

950To

10G

7 Mo/s

oui

privé

p2chpd

localhost

/tmp

ext3/ext4/xfs

>100Go

FS local

non

non

ouvert

p2chpd

localhost

/dev/shm

ext3/ext4/xfs

<10Go

FS local

non

non

ouvert

p2chpd

3. Environnement de travail.

Chaque utilisateur dispose d’un compte personnel. Votre espace de travail par défaut est hébergé sur un montage NFS: /home_nfs/${group}/${login}. Votre Groupe Unix Principale est dépend de votre laboratoire ou unité de recherche. Votre login est composé de vos prénoms et noms. Les systèmes de fichier sont soumis à des quotas disques utilisateurs. Le principal système de fichier pour tous les utilisateurs est:

  • /home_nfs, 140TO d’espace disque en RAID6 sauvegardé.

Une partition ‘scratch’ est disponible sur les nœuds de calcul uniquement:

  • /scratch, 40To, performant mais non sauvegardé.

Le système d’exploitation installé sur toutes les ressources de calcul est un système Linux, plus précisément une distribution CentOS. Les logiciels et bibliothèques de calcul sont recompilés et optimisés avec EasyBuild selon les architectures matérielles (prise en compte des différentes générations d’instruction vectorielle). Les commandes "module" permettent d’y accéder.

4. Ressources Réseaux.

A completer.

5. Comment utiliser les ressources de calcul.

Le centre de calcul exploite différentes générations et technologies de calculateur sous la forme d’un cluster (architecture de type cluster BEOWULF). Les serveurs incluent dans le cluster sont appelés des 'nœuds'. Ils sont de type différent:

  • Nœuds de login: Passerelles donnant accès de l’extérieur aux ressources de calcul et de stockage (Protocole SSH, routeur/NAT TCP, proxy). La compilation, l’exécution batch ou interactive de code n’y sont pas autorisés. Ces nœuds permettent l’accès au centre de calcul, l’édition ou le transfert de fichier et la gestion des jobs exécutés sur le cluster.

  • Nœuds de service: Serveurs exécutant les services réseaux nécessaires au fonctionnement du cluster (DHCP, PXE, TFTP, DNS, NTP, LDAP, SLURM, FLEXLM).

  • Nœuds de calcul: Serveurs exécutant les codes de simulation en batch ou interactif, la compilation ou le ‘debbug’ d’application.

  • Nœuds de stockage: Serveurs de fichiers reseaux distribués (LUSTRE, NFS, CEPH, IRODS).

Pour permettre un partage équitable et une utilisation optimale des ressources, un gestionnaire de ressource (Ressource Manager/ Batch manager) gère les demandes des utilisateurs. L’outil installé au P2CHPD est le ‘Ressource Manager’ SLURM. Il permet:

  • de spécifier les ressources physiques en fonction des besoins des codes,

  • de planifier le lancement des jobs soumis (départ, durée maximum, etc),

  • de réserver les ressources nécessaires au bon déroulement d’une simulation et de garantir leur utilisation,

  • d’ordonnancer les jobs lancés soumis par les utilisateurs,

  • de sécuriser les accès (SSH, mémoire, etc) aux codes exécutés sur les nœuds de calcul, partagés ou non,

  • de monitorer l’exécution des taches et l’usage des ressources.

’accéder au centre’

5.1. Détails sur SLURM.

SLURM propose 2 types d’exécution des taches:

  • en mode Batch: Il gère la totalité du cycle de vie de vos taches et écrit les logs dans un fichier sans connexion persistante nécessaire sur le cluster. C’est le mode qu’il est préférable d’utiliser.

  • en mode Interactif (avec ou sans affichage graphique): Ce mode offre une session Shell(BASH) à l’utilisateur qui lui permettra d’exécuter les commandes voulues sur les ressources allouées. ATTENTION, dans ce cas, une perte de connexion sur le Cluster (ssh) arrête l’ensemble de vos applications. Il peut être utile pour compiler/debugger ou exécuter des applications nécessitant une interface graphique ou une certaine interactivité.

’soumettre une tache à exécuter sur les ressources de calcul’

Dans tous les cas, il est nécessaire de préciser les ressources de calcul que l’on souhaite utiliser dont:

  • Le nombre de nœuds, sockets, cœurs et mémoire.

  • La partition (groupe de nœuds physiques) qui fournira les ressources de calcul.

  • La durée de votre calcul.

Si vous ne précisez pas votre demande, les valeurs par défaut seront appliquées à votre tache (nbre nœud=1, nbre socket=1, nbre cœur = 1, partition = default_p2chpd, durée du calcul = 1 Jour et 1 Heure).

Les nœuds de calcul du P2CHPD sont regroupés en partition qui dépendent de leur fonction et de leur matériel. Il existe actuellement 2 partitions accessibles à tous pour vos calculs (d’autres sont réservées à des groupes ou des projets particulier):

  • default_p2chpd: La partition par défaut. Elle regroupe l’ensemble des nœuds du Cluster. Elle est destinée à la compilation, au ‘debugging’ et à l’exécution de job séquentiel ou parallèle par mémoire partagée (thread).

  • parallel: Cette partition est dédiée au calcul par mémoire distribuée (MPI par exemple). Les nœuds de calcul de chaque partition sont interconnectés par un réseau rapide Infiniband FDR pour faciliter les échanges de données entre les processus d’une simulation parallelisée.

Table 3. Liste des commandes essentiels du ‘batch manager’.
commande description

sbatch

Demander l’exécution d’un script en batch

salloc

Demander des ressources et exécuter une commande ou un script

srun

Distribuer et exécuter un job parallèle avec allocation des ressources

interactive

Demander une session interactive (avec X forwarding)

squeue

Récupérer des infos sur la file d’attente et l’état des jobs

sinfo

Récupérer des infos sur le cluster/partitions/jobs

scancel

Terminer un job

sacct

Récupérer des infos sur ses jobs et ressources utilisées

scontrol

Modifier des paramètres de jobs en cours d’exécution

sview

Interface graphique pour visualiser l’état des jobs et du cluster

smap

Vue graphique des allocations/partition/jobs/cluster

Table 4. Exemples de commandes.

scontrol show jobid -dd <jobid>

information détaillé d’un job

scancel -t PENDING -u <username>

annuler tous les jobs en, attente de username

sinfo -Nl

lister les noeuds de calcul et leurs propriétés

sreport cluster AccountUtilizationByUser start=2020-01-01 accounts=<votre_account> -t hours

suivit de sa consommation heure

scontrol show job <jobid> | grep StartTime=

date estimé de démarrage du job

sprio -l

Priorité des jobs (dépend du temps de calcul annoncé, du nombre de cœurs, de l’historique de l’utilisation, etc

Table 5. Variables d’environnement de SLURM.

SLURM_NPROCS

nombre de cœurs alloués

SLURM_NNODES

nombre de nœuds alloués

SLURM_CPUS_ON_NODE

nombre de cœurs alloués par nœud

SLURM_JOB_ID

job id

SLURM_JOB_NODELIST

liste des nœuds alloués

5.2. Bibliothèques et logiciels de calcul (EasyBuild/LMOD module system)

De nombreux programmes, sous différentes versions, sont installés et disponibles sur les nœuds de calcul (pas sur les nœuds de login ou de services). Pour les utiliser, sans générer de conflit, dans votre environnement shell (BASH), vous devez charger leur configuration avec la commande ‘module’.

Table 6. Commandes module

module avail

affiche les paquets logiciels qui peuvent être configurés et utilisés

module list

liste les paquets configurés dans l’environnement SHELL

module load foo

installe la configuration du paquet logiciel foo

module rm foo

désinstalle la configuration du paquet foo

module purge

désinstalle la configuration de tous paquets logiciels

Par défaut, très peu de logiciels sont préconfigurés sur un compte utilisateur. Il est nécessaire de préciser explicitement les répertoires d’installation des modules avec l’option ‘use PATH’. Actuellement les modules sont installés dans:

  • /softs_eb/CentOS/6/core2/modules/all

Il est possible de configurer l’environnement module du SHELL du compte utilisateur en modifiant le fichier ~/.bashrc.

Exemple de configuration manuelle après connexion sur un nœud de calcul.
[user@node418 ~]$ module list
no modules loaded
[user@node418 ~]$ module av
------------------------------------------------------- /etc/modulefiles
-------------------------------------------------------

--------------------------------------------
/usr/share/lmod/lmod/modulefiles/Core
---------------------------------------------
lmod/6.5.1    settarg/6.5.1

Use "module spider" to find all possible modules.
Use "module keyword key1 key2 ..." to search for all possible modules
matching any of the "keys".

[user@node418 ~]$ module use /softs_eb/CentOS/6/core2/modules/all
[user@node418 ~]$ module av
---------------------------------------------
/softs_eb/CentOS/6/core2/modules/all
---------------------------------------------
 Autoconf/2.69-GCCcore-8.3.0					 binutils/2.32-GCCcore-8.3.0
 Automake/1.16.1-GCCcore-8.3.0					 binutils/2.32                                  (D)
 Autotools/20180311-GCCcore-8.3.0				 bokeh/1.4.0-foss-2019b-Python-3.7.4
 Bison/3.3.2-GCCcore-8.3.0						 bzip2/1.0.8-GCCcore-8.3.0
 Bison/3.3.2				(D)					 cURL/7.66.0-GCCcore-8.3.0
 Boost/1.71.0-gompi-2019b						 dask/2.8.0-foss-2019b-Python-3.7.4
 CGAL/4.14.1-foss-2019b-Python-3.7.4			 double-conversion/3.1.4-GCCcore-8.3.0
 CMake/3.15.3-GCCcore-8.3.0						 expat/2.2.7-GCCcore-8.3.0
 DBus/1.13.12-GCCcore-8.3.0						 flatbuffers/1.12.0-GCCcore-8.3.0
 Doxygen/1.8.16-GCCcore-8.3.0					 flex/2.6.4-GCCcore-8.3.0
 EasyBuild/4.3.1								 flex/2.6.4					(D)
 EasyBuild/4.3.2		(L,D)					 fontconfig/2.13.1-GCCcore-8.3.0
 Eigen/3.3.7									 foss/2019b
 FFTW/3.3.8-gompi-2019b							  freetype/2.10.1-GCCcore-8.3.0
 FFmpeg/4.2.1-GCCcore-8.3.0						 gc/7.6.12-GCCcore-8.3.0
 FriBidi/1.0.5-GCCcore-8.3.0					gettext/0.19.8.1
 GCC/8.3.0										   gettext/0.20.1-GCCcore-8.3.0					(D)
 GCCcore/8.3.0									  git/2.23.0-GCCcore-8.3.0-nodocs
 GLib/2.62.0-GCCcore-8.3.0						 gmpy2/2.1.0b4-GCC-8.3.0
 GROMACS/2020-foss-2019b						   gperf/3.1-GCCcore-8.3.0
 GSL/2.6-GCC-8.3.0								h5py/2.10.0-foss-2019b-Python-3.7.4
 HDF5/1.10.5-gompi-2019b						 LAME/3.100-GCCcore-8.3.0
 LAMMPS/3Mar2020-foss-2019b-Python-3.7.4-kokkos		LLVM/9.0.0-GCCcore-8.3.0
 METIS/5.1.0-GCCcore-8.3.0							libevent/2.1.11-GCCcore-8.3.0
 ....................................

[user@node418 ~]$ module load foss/2019b
[user@node418 ~]$ module list
module list

Currently Loaded Modules:
  1) EasyBuild/4.3.2                7) XZ/5.2.4-GCCcore-8.3.0           13)	 gompi/2019b
  2) GCCcore/8.3.0                  8) libxml2/2.9.9-GCCcore-8.3.0      14)  FFTW/3.3.8-gompi-2019b
  3) zlib/1.2.11-GCCcore-8.3.0      9) libpciaccess/0.14-GCCcore-8.3.0  15) ScaLAPACK/2.0.2-gompi-2019b
  4) binutils/2.32-GCCcore-8.3.0   10) hwloc/1.11.12-GCCcore-8.3.0      16) foss/2019b
  5) GCC/8.3.0                     11) OpenMPI/3.1.4-GCC-8.3.0
  6) numactl/2.0.12-GCCcore-8.3.0  12)OpenBLAS/0.3.7-GCC-8.3.0
Exemple de configuration automatique du SHELL avec le fichier ~/.bashrc du compte utilisateur.
# Source global definitions
if [ -f /etc/bashrc ]; then
        . /etc/bashrc
fi

# User specific aliases aind functions
alias cp='cp -i'
alias mv='mv -i'
export EASYBUILD_MODULES_TOOL=Lmod

# Definition du PATH des modules en fonction de l'OS et du materiel.
OS_NAME=$(lsb_release -i | awk '{print $3}')
OS_VERSION=$(lsb_release -r | awk '{print $2}')
OS_VERSION_MAJOR=$(echo ${OS_VERSION} | awk '{split($0, a, "."); print  a[1]}')
CPU_ARCH=$(gcc -march=native -Q --help=target | grep march | awk '{print $2}')
EASYBUILD_PREFIX="/softs_eb/${OS_NAME}/${OS_VERSION_MAJOR}/${CPU_ARCH}"
export EASYBUILD_PREFIX=${EASYBUILD_PREFIX}
module use ${EASYBUILD_PREFIX}/modules/all

Dans la suite des exemples du manuel, on supposera que l’environnement module est correctement initialisé par le fichier \~/.bashrc modifié comme précédemment. Pour plus d’information sur la commande ‘module’: man module.

6. Exemples d’utilisation.

6.1. Connexion au centre de calcul et transfert de fichier

Pour se connecter au centre de calcul et à ses ressources, vous devez, au préalable, transmettre une clée publique SSH lors d’une demande de création de compte (https://p2chpd.univ-lyon1.fr/acces). Seules les connexions SSH, avec clé, sur les nœuds de login sont autorisées. Toutes les applications compatibles SSHv2 permettent de se connecter en SSH sur le nœud de login (p2chpd-login3.univ-lyon1.fr), passerelle SSH du centre.

6.1.1. Solution pour un accès à partir d’un système Linux ou MACOS (SHELL/SSH)

Pre-requis:

  • une configuration de votre environnement SSH avec vos clés publiques/privées,

  • pour les utilisateurs MacOS qui souhaite le transfert de l’affichage graphique X11 via SSH ou X2GO, une installation sur server 'Xquartz'

Le logiciel OpenSSH est généralement disponible sur les distributions Linux.

Pour l’utiliser, ouvrir un terminal et exécuter les commandes suivantes:

[user@PosteTravail ~] ssh -Y loginUserP2chpd@p2chpd-login3.univ-lyon1.fr
Last login: Tue Mar 23 17:46:06 2021 from truc.abo.wanadoo.fr
~~~~~ Bienvenue au centre de calcul P2CHPD de la FLMSN ~~~~~
------------------------------------------------------------
WARNING: You must have specific authorization to access this
machine. Unauthorized users will be logged, monitored, and
could be pursued.
-----------------------------------------------------------
~~~~~ Last news ~~~~~
~~~~~ p2chpd-login3 login system summary ~~~~~
  (collected Wed Mar 24 14:20:01 CET 2021)
   - CPU Usage (average)    = 3%
   - Memory free (real)     = 12288 Mb
   - Memory free (cache)    = 6201 Mb
   - Swap in use            = 532 Mb
   - System Uptime          = 14:20:01 up 243 days,  6:23,
   13 users,  load average: 0.83, 1.01, 1.00
   - Public IP              = XXX.XXX.XXX.XXX
   - Home_nfs disk Space    = 89%

~~~~ Computing ressources ~~~~~

	Nodes online = 320
	Nodes free on parallel1  = /36
	Nodes free on parallel2  = /36
	Nodes free on parallel partition = 6/220
	Jobs currently running = 52
~~~~~ More informations ~~~~~
You are not allowed to use p2chpd-login3 in rder to compute!
So, use Slurm batch manager (sinfo, squeue, salloc, srun, sbatch, scancel,...) to get some computing ressources
See http://slurm.schedmd.com for manual and tutorial)
Your quota on Home_nfs filesystem => use 'quota' command.
Ref - https://p2chpd.univ-lyon1.fr
[loginUserP2chpd@p2chpd-login3 ~]#

6.1.2. Solution pour un accès à partir d’un systéme Windows

PuTTY est un client SSH et telnet pour Windows. Vous pouvez télécharger ce client ici: https://www.putty.org. Pre-requis: Installation d’un serveur Xorg sur le systeme windows (Xming)

Pour configurer la connexion :

  • Session > Host Name : hpc-login.u-strasbg.fr ;

  • Connection > SSH > Auth : Private key file for authentication : indiquez le chemin vers votre clé ssh privée ;

  • Connection > SSH > Auth > X11 : cochez Enable X11 forxarding si vous avez besoin d’un affichage graphique (pensez à lancer un serveur Xming au préalable);

  • Sauvegarder vos réglages dans l’onglet Session.

Un autre logiciel, ‘MobaXTerm’ (version gratuite), peut être utilisé pour remplacer ‘Putty’ si besoin.

6.2. Transfert de fichier

Les outils classiques Linux (scp, rsync, etc) ou des logiciels comme ‘FileZilla’ peuvent utiliser le protocole SSH pour échanger un ou plusieurs fichiers.

6.2.1. scp

Depuis votre poste de travail vers le centre de calcul:

scp -r <fichier.ou.repertoire.data.source> <loginUser>@p2chpd-login3.univ-lyon1.fr:<fichier.ou.repertoire.destination> # À exécuter sur votre poste de travail.

Depuis le centre de calcul vers votre poste de travail:

scp -r <loginUser>@p2chpd-login3.univ-lyon1.fr:<fichier.ou.repertoire.data.source> <fichier.ou.repertoire.destination> # À exécuter sur votre poste de travail.

6.2.2. rsync

Le logiciel 'rsync' est un logiciel OpenSource multiplateforme, sans interface graphique.

Pour transférer un fichier du poste de travail vers le centre de calcul, exécutez les commandes suivantes dans un terminal (Linux ou MACOS) sur votre station de travail:

rsync -e ssh -avz fichier.Ou.Repertoire <loginUser>@p2chpd-login3.univ-lyon1.fr:<fichier.Ou.Repertoire>

Pour transferer un fichier du centre de calcul vers votre poste de travail, executer les commandes suivantes dans un terminal (Linux ou MACOS) toujours à partir de votre station de travail:

rsync -e ssh -avz <loginUser>@p2chpd-login3.univ-lyon1.fr:<fichier.Ou.Repertoire.source> <fichier.Ou.Repertoire.de.destination>

6.2.3. FileZilla

‘Fillezilla’ est un logiciel de transfert de fichier multi-protocole, opensource, multi-système, avec une interface graphique. Pour configurer une connexion entre le centre de calcul et votre poste de travail, appliquer la configuration suivante:

  • Fichier > Gestionnaire de sites (ou Ctrl+S);

  • Nouveau Site;

    • Hôte: p2chpd-login3.univ-lyon1.fr;

    • Protocole: SFTP - SSH Filter Transfert Protocol;

    • Type d’authentification: Fichier de votre clé privée;

6.3. Exécution d’un job en batch

Pour exécuter un job sur une partie des ressources du centre, il faut créer un script SHELL qui décrit les ressources puis lancer son programme. On soumet ce script gestionnaire de batch SLURM la commande ‘sbatch’:

[loginUser@p2chpd-login3 ~]$sbatch mon_script

Une fois soumis, un identifiant unique 'jobid' est associé au job permettant leur gestion (commandes scancel, squeue ou scontrol). Par défaut, la sortie standard du job est redirigée un fichier, slurm-${jobid}.out.

#!/bin/sh
# script Bash pour l'execution d'une tach par slum.
## Nom de la tache soumise
#SBATCH -J TESTJOB
## nbre de coeur demandé sur le serveur
#SBATCH -n 1
## temps d'execution du job demandé
#SBATCH -t 30:00:00
# quantité de mémoire disponible à reserver sur le serveur
#SBATCH --mem=8G
# Nom du fichier de log stdout de la tache
#SBATCH -o %j.out
# Nom du fichier de log stderr de la tache
#SBATCH -e %j.err
# Envoie de mail pour notification de l'etat du job
#SBATCH --mail-type=ALL
# adresse mail du destinataire
#SBATCH --mail-user=<email:user@domain>

# quelques commandes bash pour tester l'envirronnement.
hostname
pwd
whoami
module show foss/2019a
cd $JOBDIR
export | grep SLURM
[user@p2chpd-login3 ~]sbatch script_batch_simplke.sh
Submitted batch job 806298
[user@p2chpd-login3 ~]$ squeue -u user
JOBID PARTITION     NAME     USER ST       TIME  NODES NODELIST(REASON)
806298 default_p  TESTJOB    cpera  R       0:05     1 node395
[user@p2chpd-login3 ~]$ sacct -j 806298
JobID        JobName    Partition   Account     AllocCPUS State      ExitCode
------------ ---------- ----------  ---------- ---------- ---------- --------
806298          TESTJOB default_p+  testing          1     COMPLETED      0:0
806298.batch      batch  testing					 1	   COMPLETED      0:0
[user@p2chpd-login3 ~]$ls -alrt
total 52
-rw------- 	1 	user	users 	711		8	mars	13:53	script_batch_simple.sh
drwxr-xr-x	116	user	users	8192	8	mars	13:53	..
drwx------	2	user	users	4096	8	mars	13:54	.
-rw-------	1	user	users	195		8	mars	13:54	806298.err
-rw-------	1	user	users	942		8	mars	13:54	806298.out
[user@p2chpd-login3	~]$ cat 806298.out
node395
/home_nfs/user/test_manuel_rhel6
user
export SLURMD_NODENAME="node395"
export SLURM_CHECKPOINT_IMAGE_DIR="/home_nfs/user/test_manuel_rhel6"
export SLURM_CPUS_ON_NODE="1"
export SLURM_GTIDS="0"
export SLURM_JOBID="806298"
export SLURM_JOB_CPUS_PER_NODE="1"
export SLURM_JOB_ID="806298"
export SLURM_JOB_NAME="TESTJOB"
export SLURM_JOB_NODELIST="node395"
export SLURM_JOB_NUM_NODES="1"
export SLURM_LOCALID="0"
export SLURM_MEM_PER_NODE="8192"
export SLURM_NNODES="1"
export SLURM_NODEID="0"
export SLURM_NODELIST="node395"
export SLURM_NODE_ALIASES="(null)"
export SLURM_NPROCS="1"
export SLURM_NTASKS="1"
export SLURM_PRIO_PROCESS="0"
export SLURM_PROCID="0"
export SLURM_SUBMIT_DIR="/home_nfs/user/test_manuel_rhel6"
export SLURM_SUBMIT_HOST="p2chpd-login3"
export SLURM_TASKS_PER_NODE="1"
export SLURM_TASK_PID="61645"
export SLURM_TOPOLOGY_ADDR="swib[1-3].swib9.node395"
export SLURM_TOPOLOGY_ADDR_PATTERN="switch.switch.node"

[user@p2chpd-login3	~]$ cat 806298.err
[user@p2chpd-login3 ~]$

6.4. Exécution d’un job interactif

Le travail en interactif sur les nœuds réservés peut être utile pour le développement, l’analyse des codes, pour l’interaction avec certains codes graphiques, etc. Contrairement au job batch, les jobs interactifs sont trés 'sensibles' aux interruptions réseaux. Une perte de connexion entre votre station de travail et le nœud de login utilisé arrêtera immédiatement votre session interactive et les applications associées. Pour réserver des ressources et démarrer une session interactive, on peut utiliser les commandes ‘salloc’ ou ‘srun’.

# Reservation et ouverture d'un shell interactif sur un noeud de la partition
# parallel
[user@p2chpd-login3 ~]$ srun -p parallel --pty /bin/bash
[user@node315 ~]$

# Reservation et ouverture d'un shell interactif pour un calcul parallel sur plusieurs noeuds de la partition
[user@p2chpd-login3 ~]$srun --partition=parallel --nodes=2 --ntasks-per-node=4 --cpus-per-task=1 --mem=8000 --time=0-01:00:00 --pty /bin/bash
[user@node315 ~]$
# Reservation s connexion sur le ou les noeuds reserver
# parallel
[user@p2chpd-login3 ~]$salloc -p parallel --nodes=2 --ntasks-per-node=4 --cpus-per-task=1 --mem=8000 --time=0-01:00:00
[user@p2chpd-login3 ~]$squeue -u user
            JOBID PARTITION     NAME     USER ST       TIME  NODES NODELIST(REASON)
			806325  parallel   salloc   user  R      00:01      2	node[315,316]
[user@p2chpd-login3 ~]$ssh node315
[user@node315 ~]$srun path/job_mpi

Dans la suite des exemples, on supposera que les accès sur les nœuds de calcul se feront en mode interactif avec les commandes ‘salloc/squeue/ssh’.

6.5. Worflows et recommandations pour une utilisation ‘batch’ standard des ressources.

  • Se connecter sur un nœud de login du centre de calcul en SSH et transférer les fichiers nécessaires à vos codes/simulations.

  • Écrire le script de soumission monscript.sbatch.

  • Soumettre le script de batch: sbatch monscript.sbatch.

  • Vérifier le fichier d’erreur .err et le fichier de sortie standard .out.

  • Monitorer le ou les jobs soumis (squeue, etc).

  • Vérifier vos résultats.

  • Nettoyer impérativement l’espace de travail (suppression des fichiers temporaires pour éviter un dépassement de quota).

  • Transférer vos fichiers résultats dans votre home, sur un serveur d’archivage, etc.

6.6. compilation et debug

6.6.1. Compilateur GCC (C/C\++/Frotran)

Les compilateurs GNU sont disponibles sur l’ensemble des nœuds de calcul. Attention, les compilateurs ne sont pas disponibles sur les nœuds de login. Les processeurs y étant différents des nœuds de calcul, il est pénalisant de générer du code en fonction de leurs instructions (pas d’optimisations AVX, AVX2, etc). La version par défaut est la version du système d’exploitation (4.8). Les versions récentes sont accessibles dans les environnements ‘module’.

[user@node418 ~]$ module load foss/2019b
[user@node418 ~]$ module list
Currently Loaded Modules:
1) EasyBuild/4.3.2             4) binutils/2.32-GCCcore-8.3.0    7)XZ/5.2.4-GCCcore-8.3.0           10) hwloc/1.11.12-GCCcore-8.3.0  13) gompi/2019b                  16) foss/2019b
2) GCCcore/8.3.0               5) GCC/8.3.0                      8)libxml2/2.9.9-GCCcore-8.3.0      11) OpenMPI/3.1.4-GCC-8.3.0      14)FFTW/3.3.8-gompi-2019b
3) zlib/1.2.11-GCCcore-8.3.0   6) numactl/2.0.12-GCCcore-8.3.0   9)libpciaccess/0.14-GCCcore-8.3.0  12) OpenBLAS/0.3.7-GCC-8.3.0     15) ScaLAPACK/2.0.2-gompi-2019b

Les commandes:

  • gcc: compilateur C.

  • g++: compilateur C++.

  • gfortran: compilateur fortran.

Un exemple de compilation et d’exécution en interactif.

Un fichier exemple C ‘Hello_World.c’ OpenMP
#include <stdio.h>
#include <omp.h>
#include <unistd.h>

int main (int argc, char *argv[]) {
	int nb_procs;   //Nombre de thread openMP
    int id;       //identifiant du thread
	nb_procs = omp_get_max_threads();
	#pragma omp parallel private(id){
		rang = omp_get_thread_num();
		printf("Hello World thread %d/%d\n",id,nb_procs);
	}
	return 0;
}
Compilation et exécution sur le nœud node418
[user@p2chpd-login3 ~]$ salloc -N1 -n4 -p parallel
[user@p2chpd-login3 ~]$ squeue -u user
node418
[user@p2chpd-login3 ~]$ ssh node418
[user@node418 ~]$ module load foss/2019b
[user@node418 ~]$ gcc --version
gcc (GCC) 8.3.0
Copyright (C) 2018 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
[user@node418 ~]$ gcc -O3 -march=native Hello_World.c -o hello -fopenmp
[user@node418 ~]$ export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK ./hello

6.6.2. Compilateur Intel (C/C\++/Frotran)

La suite de développement Intel Cluster Suite est installé sur tous les nœuds de calcul. Plusieurs versions sont disponibles et peuvent être sélectionnées avec la commande: module load intel/${version}.

Un exemple de compilation interactive d’un code multithread OpenMP sur le serveur node418.
[user@node418 ~]$ module load foss/2019b
[user@node418 ~]$ module list
Currently Loaded Modules:
 1) EasyBuild/4.3.2             4) binutils/2.32-GCCcore-8.3.0           7)iimpi/2019b
 2) GCCcore/8.3.0               5) iccifort/2019.5.281		  8) imkl/2019.5.281-iimpi-2019b
 3) zlib/1.2.11-GCCcore-8.3.0   6) impi/2018.5.288-iccifort-2019.5.281   9) intel/2019b
[user@node418 ~]$ icc hello_world_openmp.cpp -o hello_world -qopenmp

6.6.3. Compilateur OpenACC/CUDA (C/C\++)

Les environnements CUDA et PGI sont installés sur les nœuds de calcul GPU. Ils sont accessibles par les modules ‘fosscuda’ et ‘PGI’.

Exemple de fichier source CUDA ‘hello_world.cu’
#include <cstdio>
#include "cuda.h"

void CPUFunction() {
  printf("hello from the Cpu.\n");
}

__global__
void GPUFunction() {
  printf("hello from the Gpu.\n");
}

int main() {
  CPUFunction();
  GPUFunction<<<1, 1>>>();
  cudaDeviceSynchronize();
  return EXIT_SUCCESS;
}
Exemple de compilation et exécution sur le nœud node418-gpu
[user@node418-gpu ~]$ module load fosscuda/2019b
[user@node418-gpu ~]$ module list
Currently Loaded Modules:
  1) GCCcore/8.3.0                 5) CUDA/10.1.243-GCC-8.3.0        9) libxml2/2.9.9-GCCcore-8.3.0      13) OpenBLAS/0.3.7-GCC-8.3.0      17) fosscuda/2019b
  2) zlib/1.2.11-GCCcore-8.3.0     6) gcccuda/2019b                 10) libpciaccess/0.14-GCCcore-8.3.0  14) gompic/2019b
  3) binutils/2.32-GCCcore-8.3.0   7) numactl/2.0.12-GCCcore-8.3.0  11) hwloc/1.11.12-GCCcore-8.3.0      15) FFTW/3.3.8-gompic-2019b
  4) GCC/8.3.0                     8) XZ/5.2.4-GCCcore-8.3.0        12) OpenMPI/3.1.4-gcccuda-2019b      16) ScaLAPACK/2.0.2-gompic-2019b
[user@node418-gpu ~]$ nvcc -o out hello_world.cu -run

6.6.4. Autres (Python, Julia, R, etc)

De nombreux environnements de développement et langages de programmation sont disponibles en tant que module sur les nœuds de calcul. Pour consulter les logiciels disponibles et leur version: "module av"

Exemple d’utilisation de python sur le nœud node418
[user@node418 ~]$ module list
No modules loaded
[user@node418 ~]$ module av
		.....
[user@node418 ~]$ which python
/usr/bin/python
[user@node418 ~]$ python --version       # System level python
Python 2.7.5
[user@node418 ~]$ module load Python/3.7.4-GCCcore-8.3.0    # use TAB to auto-complete
[user@node418 ~]$ which python
/softs_eb/CentOS/6/core2/software/Python/3.7.4-GCCcore-8.3.0/bin/python
[user@node418 ~]$ python --version
Python 3.7.4
[user@node418 ~]$ module purge

6.7. Exécution d’un job parallel MPI

OPENMPI est l’implémentation MPI installée sur les nœuds sous forme de module. Il est recompilé avec l’API de Slurm et doit être utilisé avec la commande ‘srun’, au lieu de l’habituel ‘mpirun’. Par défaut, ‘srun’ lancera les taches en fonction des demandes de réservation passée à SLURM. Plusieurs optimisations sont mises en place dont:

  • Intégration des communications par le réseau INFINIBAND s’il est présent.

  • Gestion des placements des processus sur les nœuds sans migration sur les cœurs.

  • Gestion des placements en fonction des accès mémoires.

Un exemple de job MPI de 32 cœurs, qui sera distribué sur 4 nœuds de 8 cœurs (4x8=32) par défaut:

#! /bin/bash

#SBATCH -n 32					# 32 cœurs répartis en bloc sur le minimum de noeud
#SBATCH -p parallel				# Reservation sur la partition parallel, un cluster de noeud interconnecté par un réseau infiniband
#SBATCH -t 2:00:00				# Le job sera tué au bout de 2h
#SBATCH --mail-type=END			# Réception d'un mail à la fin du job
#SBATCH --mail-user=adresse_mail

module load openmpi
srun executable_mpi

6.8. Exécution d’un job parallèle ‘OpenMP’

Les threads ‘OpenMP’ sont distribuées manière compacte sur les cœurs d’un même socket, puis des autres sockets du serveur.

Voici un exemple de script d’un job OpenMP qui utilisera 2 sockets sur un serveur de 16 cœurs et 2 sockets.

#! /bin/bash

#SBATCH -N 1		# reservation d'un noeud
#SBATCH -p parallel # selection de la partition "parallel", nœuds bisocket 8 coeurs
#SBATCH -n 1		# 1 seul tâche
#SBATCH -c 16		# 16 cœurs pour ce job

./code_omp

6.9. Exécution d’un job parallèle ‘OpenMP/MPI’

Une application ‘MPI/OpenMP’ (N processus qui exécutent n threads ‘OpenMP’) doit réserver N serveurs et Nxn cœurs. Pour optimiser ce type de calcul, on choisit généralement 1 processus MPI par serveur et n threads OpenMP sur chacun des serveurs).

Options utiles:

  • SLURM_CPUS_ON_NODE qui donne le nombre de cœurs disponibles.

  • --tasks-per-node=1 qui distribue 1 processus MPI par nœud.

#! /bin/bash

#SBATCH -N 2					# Réservation sur 2 nœuds
#SBATCH –tasks-per-node=2			# 2 processus MPI par nœud
#SBATCH -c 4					# 4 cœurs par tâche

export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK # Nombre de thread OpenMP par noeud
srun ./code_openMP_MPI

6.10. Exécution d’un job CUDA/OpenACC

Pour réserver un nœud avec GPU, il suffit d’indiquer l’option: --gres=gpu:x avec le nombre de GPU par nœuds (4 au maximum) et utiliser une partition GPU (gpu, visu).

Options et variables d’environnement utiles:

  • CUDA_VISIBLE_DEVICES identifie le numéro de la carte affectée à la tâche.

  • --constraint=’modèle carte GPU’ pour sélectionner une carte GPU particulière. Certaines sont en simple précision (Visu/Deep Learning/IA), d’autre en double précision.

Un exemple de script GPU pour 1 nœud et 2 GPU en simple précision (Carte NVIDIA k20m).

#! /bin/bash

#SBATCH -p gpu-sp			# Partition gpu simple precision
#SBATCH -N 1				# 1 serveur
#SBATCH --exclusive			# Le nœud est dédié
#SBATCH -t 05:00:00			# Temps maximum du job 5h
#SBATCH --gres=gpu:2        # 2 GPU
#SBATCH --constraint=k20m	# GPU k20m simple précision
#SBATCH --mail-type=END
#SBATCH --mail-user=mon@adresse

module load CUDA
./appli_gpu_cuda

6.11. Remarques:

Limites propres à chaque utilisateur:

  • On ne peut pas utiliser plus de 56 cœurs de calcul par job/tache.

  • On ne peut pas exécuter plus de 4 jobs simultanément.

  • On ne peut pas utiliser plus de 17 nœuds de calcul sur l’ensemble des jobs en cours d’exécution (pas plus de 4).

  • Limites propres aux partitions physiques définies sur le Cluster.

  • On ne peut pas soumettre plus de 250 taches globalement sur le Cluster.

  • default_p2chpd: Durée maximum du calcul = 1 Jour et 1heure, nombre de nœuds maximum = 1 (soit 8 cœurs de calcul sur un seul nœud).

  • Parallel: Durée maximum du calcul = 2 Jours et 3 heures, nombre de nœuds maximum = 7 (soit 56 cœurs de calcul sur 7 nœuds).

Ces contraintes peuvent varier ponctuellement en fonction de l’utilisation et des besoins.

7. Ressources documentaires

8. Annexes

image:./image/planTechniqueSalleP2chpd.png[scaledwidth=16cm, width=100%,align="center",alt="plan du centre de calcul"