TORQUE

• ALTAIR FLUX
• ALTAIR HYPERWORKS
• ANSYS
• ESI VA ONE
• LSTC LS-DYNA
• MATHWORKS MATLAB
• MSC ADAMS
• NVIDIA CUDA et cuDNN TK
• SIMULIA ABAQUS
• SIMULIA FE-SAFE
• SIMULIA TOSCA
• SIMULIA SIMPACK
• TORQUE

• Introduction
• Noeuds de calculs
• Charge de calculs
• Espaces de stockage
• Exemples détaillés
  • Exemple simple - Bonjour
  • Exemple avancé - Génération automatique d’un ensemble requêtes
• Documentations

Introduction

TORQUE (Terascale Open-source Resource and QUEue manger) est un environnement logiciel de gestion de tâches («batchs»), chargé de répartir les travaux («jobs») de calculs sur des serveurs («nœuds«) de calculs selon certains critères comme la puissance de calculs disponible par exemple.

Il est disponible sur l’ensemble des serveurs PILCAM2, hors serveurs «simplex» et «nodal», qui doivent être utilisés sans TORQUE.

Ainsi, un calcul peut-être distribué par TORQUE sur n’importe quel nœud de calculs, mais pas sur «nexstor» (serveur d’administration, de sauvegarde et d’archivage), ni sur «diler» (serveur de licences et d’échange de fichiers). Les nœuds de calculs du cluster «matrics» sont accessibles, mais pas le serveur maître «matrics» lui-même, qui héberge le système TORQUE (serveur, ordonnanceur de tâches).

Le principe de fonctionnement de TORQUE est assez simple : vous construisez un script SHELL que vous lui soumettez à l’aide de la commande qsub et de paramètres comme le nœud (ou la ’catégorie’ de nœuds) de calculs que vous souhaitez utiliser. Ce «job» de calculs est alors introduit dans une file de gestion, et un état d’attente lui est affecté. Pendant ce temps, l’ordonnanceur de tâches cherche un nœud de calculs libre et correspondant aux critères souhaités. Une fois trouvé, le «job» est distribué sur ce nœud, son état passe à exécution dans la file de gestion, puis il est exécuté. Enfin, le calcul s’achève et le «job» passe, dans la file de gestion, à l’état terminé. Il demeure quelques minutes encore dans la file de gestion, puis disparaît. Dès que le «job» est à l’état terminé, vous pouvez récupérez ses sorties d’écran et d’erreur dans deux fichiers dédiés, ainsi que tout autre fichier qu’il aurait pu générer lors de son exécution.

A tout moment, vous pouvez consulter l’état de vos «jobs» dans la file de gestion à l’aide de la commande qstat

A tout moment, vous pouvez aussi interrompre l’un de vos «jobs» dans la file de gestion à l’aide de la commande qdel

Nœuds de calculs

Les nœuds de calculs sont les serveurs de calculs de PILCAM2 hors serveurs «simplex» et «nodal» qui doivent être utilisés sans TORQUE.

Pour une exploitation simplifiée, les nœuds de calculs ont été regroupés par ’catégorie’ selon la propriété qui les caractérise le mieux :

• ’cluster’ : nœuds de calculs du cluster de serveurs «matrics»
• ’fast’ : nœuds de calculs rapides («cosinus», «sinus» ou «vectris»)
• ’fastest’ : nœuds de calculs ultra rapides («algebra»)
• ’bigmem’ : nœuds de calculs avec beaucoup de mémoire («algebra»)

Par exemple, choisir via TORQUE le nœud de calculs ’cluster’ revient à choisir l’un des nœuds de calculs du cluster, soit «matrics004» ou «matrics008» ou ...

Nous préconisons que le choix du nœud de calculs souhaité se fasse de manière semi-automatique, par l’utilisation de cette ’catégorie’, au lieu de son nom physique, notamment pour le cluster.

Il existe, bien sûr, d’autres commandes qui pourront vous être utiles, comme qalter, qrerun, qselect, qorder, qhold, qrls, qchkpt, qsig

Pour plus de détails, veuillez vous référer au paragraphe ’Documentations’ de cet article.

Charge de calculs

Il faut absolument éviter de surcharger un nœud de calculs qui le serait déjà.

C’est là le travail de «TORQUE» de mesurer la charge actuelle des nœuds et de distribuer les calculs sur les nœuds les moins chargés.

Vous pouvez voir la charge moyenne d’un nœud de calculs par la commande pbsnodes. Par exemple, pour voir la charge sur le nœud «tensor», exécutez la commande suivante :

pbsnodes algebra

Vous obtiendrez un résultat équivalent à celui ci-dessous :

algebra
state = free
np = 96
properties = algebra,bigmem,fastest,gpu
ntype = cluster
status = rectime=1563988288,varattr=,jobs=,state=free,netload=17799963916,gres=,loadave=24.39,ncpus=96,physmem=1056130508kb,availmem=1124337584kb,totmem=1190348232kb,idletime=4816,nusers=6,nsessions=9,sessions=35895 35901 35958 36192 85147 85777 87363 119520 449961,uname=Linux algebra 3.10.0-957.21.3.el7.x86_64 #1 SMP Tue Jun 18 16:35:19 UTC 2019 x86_64,opsys=linux
mom_service_port = 15002
mom_manager_port = 15003
gpus = 1
gpu_status = gpu[0]=gpu_id=00000000:3B:00.0;gpu_product_name=Quadro P4000;gpu_display=Disabled;gpu_pci_device_id=1BB110DE;gpu_pci_location_id=00000000:3B:00.0;gpu_fan_speed=46 %;gpu_mode=Default;gpu_state=Unallocated;gpu_utilization=0 %;gpu_memory_utilization=0 %;gpu_ecc_mode=N/A;gpu_single_bit_ecc_errors=N/A;gpu_double_bit_ecc_errors=N/A;gpu_temperature=29 C,driver_ver=430.34,timestamp=Wed Jul 24 19:11:28 2019

Les valeurs remarquables (notées précédemment en gras) sont :

• loadave=24.39 : charge moyenne sur une courte période de temps

• ncpus=96 : nombre de cœurs de calculs du nœud

Ici, on remarquera que la charge de calculs est bien inférieure au maximum admissible qui est de (ncpus - 1) soit 95. En effet, par nœud de calculs, il faut toujours laisser au moins un cœur de calculs libre, pour faire fonctionner correctement le système d’exploitation.

Pour plus de détails sur les règles à respecter concernant la charge de calculs, consultez l’article suivant :

Règle générales d’exploitation - Choix du serveur de calculs - Charge du serveur

Espaces de stockage

Bien maîtriser TORQUE c’est aussi bien maîtriser les différents espaces de stockage mis à votre disposition au travers de votre compte informatique PILCAM2.

Nous vous invitons à lire la documentation à ce sujet disponible, et notamment celle concernant les variables d’environnement mises à votre disposition pour les exploiter correctement :

Règles générales d’exploitation - Compte informatique

TORQUE choisit de manière semi-automatique le serveur sur lequel sera exécuté le calcul soumis. Il peut être alors nécessaire de connaître ce serveur au moment du calcul, ou même à postériori, afin de nettoyer l’espace de stockage local de «SCRATCH» ou d’aller consulter les fichiers générés, par votre code de calculs, dans l’espace de stockage local intermédiaire.

Le nom de ce serveur est contenu, au moment du calcul, dans la variable d’environnement HOSTNAME, tout simplement. Il est alors facile de l’utiliser dans le script de calcul, ou même à postériori en envoyant sa valeur sur la sortie d’écran, celle-là même qui sera enregistrée, à la fin du calcul, dans le fichier «nom_du_job.out».

Exemples détaillés

Ces exemples détaillés nous ont été fournis par Mr Pierre-Yves Gires. Qu’il en soit, ici, remercié.

Exemple simple - Bonjour

Ce document décrit comment soumettre un calcul sur l’un des serveurs PILCAM2 en utilisant le gestionnaire de tâches TORQUE.

1. Connectez-vous, depuis votre ordinateur, sur l’un des serveurs de PILCAM2. Par exemple, connectez-vous à «sinus», à l’aide de la commande suivante :

ssh votre_login_UTC@sinus.utc.fr

2. Placez-vous dans le répertoire où vous souhaitez réaliser le calcul.

D’une manière plus générale, ce répertoire contiendra idéalement l’ensemble des ressources nécessaires pour réaliser un calcul, soit :

• le ou les scripts TORQUE
• le ou les fichiers exécutables de code de calculs
• le ou les fichiers de données entrantes pour le ou les exécutables précédents
• éventuellement le ou les scripts SHELL complémentaires, nécessaires au pré-traitements des données entrantes pour les calculs, et/ou aux post-traitements des données sortantes des calculs

3. Copiez le script TORQUE suivant dans un fichier nommé ’mon_script_torque’ et placez-le dans le répertoire souhaité pour cet exemple :

Script TORQUE ’mon_script_torque’ :

Les rôles des différentes lignes sont les suivants :

• #PBS -S /bin/bash : indique le langage de script et l’interpréter de commandes utilisé - ici, il s’agit d’un script BASH

• #PBS -N nom_requete : indique le nom de la requête, tel qu’il sera indiqué par la commande qstat (’-f’ peut être ajouté pour avoir plus de détails)

• #PBS -o $PBS_JOBNAME.out : indique le nom du fichier vers lequel seront dirigées les sorties d’écran du script

• #PBS -e $PBS_JOBNAME.err : indique le nom du fichier vers lequel seront dirigées les sorties d’erreur du script

• #PBS -l nodes=1:ppn=1:cluster : indique le nombre de nœuds (’nodes’) souhaités, le nombre de cœurs (’ppn’) souhaités, et la ’catégorie’ de nœuds souhaitée. Par exemple, la catégorie ’cluster’ correspond aux nœuds de calculs du cluster de serveurs «matrics»)

• #PBS -l walltime=200:00:00 : indique la durée pour laquelle les ressources décrites précédemment sont demandées

• cd $PBS_O_WORKDIR : indique de se déplacer dans le répertoire où la commande de soumission qsub a été exécutée. Ce répertoire doit correspondre à celui qui contient le script TORQUE (donc cet exemple ici). Ceci est nécessaire car TORQUE positionne, lors de son fonctionnement, le répertoire courant à la racine du compte courant

• echo "Bonjour" : exemple de commande simple

D’autres éléments peuvent être précisés avec le langage propre à TORQUE. Pour plus de détails, veuillez vous référer au paragraphe ’Documentations’ de cet article.

4. Exécutez le script TORQUE de requête par la commande de soumission suivante :

qsub mon_script_torque

5. Un fichier ’nom_requete.out’ est alors créé après quelques secondes. Il contient la sortie d’écran réalisée par la commande du script echo "Bonjour", soit le message «Bonjour»

6. Regardez l’état du «job» TORQUE ’nom_requete’ précédent en exécutant la commande :

qstat

Vous obtiendrez un résultat équivalent à celui ci-dessous :

Ou, avec la commande :

qstat -f

vous obtiendrez un résultat équivalent à celui ci-dessous :

Job Id: 1368.matrics.cluster
Job_Name = nom_requete
Job_Owner = utestper@sinus
resources_used.cput = 00:00:00
resources_used.mem = 0kb
resources_used.vmem = 0kb
resources_used.walltime = 00:00:01
job_state = C
queue = batch
server = matrics.cluster
Checkpoint = u
ctime = Fri Nov 21 16:03:59 2014
Error_Path = sinus:/volper/users/utestper/torque/mon_script_torque/$PBS_JO
BNAME.err
exec_host = matrics002/3
exec_port = 15003
Hold_Types = n
Join_Path = n
Keep_Files = n
Mail_Points = a
mtime = Fri Nov 21 16:04:00 2014
Output_Path = sinus:/volper/users/utestper/torque/mon_script_torque/$PBS_J
OBNAME.out
Priority = 0
qtime = Fri Nov 21 16:03:59 2014
Rerunable = True
Resource_List.nodect = 1
Resource_List.nodes = 1:ppn=1:cluster
Resource_List.walltime = 200:00:00
session_id = 10441
Shell_Path_List = /bin/bash
Variable_List = PBS_O_QUEUE=batch,PBS_O_HOME=/volper/users/utestper,
PBS_O_LOGNAME=utestper,
PBS_O_PATH=/usr/lib64/qt-3.3/bin:/opt/TurboVNC/bin:/local1/torque-4.2
.7/sbin:/local1/torque-4.2.7/bin:/usr/local/bin:/bin:/usr/bin:/usr/loc
al/sbin:/usr/sbin:/sbin:/usr/local/cuda/bin:/apl/soft/bin:/usr/local/p
ilcam2/bin:/apl/soft/LIB/mpich2-1.4.1p1/bin:/apl/soft/Pam_Crash/:/apl/
soft/telemac/bin:/volper/users/utestper/bin,
PBS_O_MAIL=/var/spool/mail/utestper,PBS_O_SHELL=/bin/bash,
PBS_O_LANG=en_US.UTF-8,
PBS_O_WORKDIR=/volpilcam/user1x/users/utestper/torque/mon_script_torq
ue,PBS_O_HOST=sinus.cluster,PBS_O_SERVER=matrics
comment = Job started on Fri Nov 21 at 16:03
etime = Fri Nov 21 16:03:59 2014
exit_status = 0
submit_args = mon_script_torque
start_time = Fri Nov 21 16:03:59 2014
start_count = 1
fault_tolerant = False
comp_time = Fri Nov 21 16:04:00 2014
job_radix = 0
total_runtime = 0.665876
submit_host = sinus.cluster

Quelques lignes remarquables (notées précédemment en gras) :

• Job Id: 1368.matrics.cluster : le numéro du «job»
• Job_Name = nom_requete : le nom du «job»
• Job_Owner = utestper@sinus : le propriétaire du «job» (ici, ’utestper’ depuis le serveur «sinus»)
• exec_host = matrics002/3 : le nœud de calcul (ici, «matrics002») et le numéro de cœur d’exécution (ici, le cœur numéro 3) du «job»
• exit_status = 0 : le code de retour du script TORQUE (ici, 0, donc tout s’est bien passé du côté de TORQUE)
• total_runtime = 0.665876 : le temps d’exécution du «job»
• submit_host = sinus.cluster : le serveur de soumission du «job»

Exemple avancé - Génération automatique d’un ensemble requêtes

Il se peut que vous souhaitiez effectuer plusieurs calculs, par exemple pour étudier la dépendance d’une propriété dans un modèle à un paramètre. De façon à générer une base de données décrivant cette relation, pour aller plus vite, vous pouvez écrire un script pour l’interpréteur de commandes SHELL, qui va exécuter automatiquement un ensemble de requêtes.

Un exemple est présenté ci-dessous, calculant n/(n+1), pour n variant de 1 à 5.
Il utilise les commandes awk et sed pour manipuler du texte dans des fichiers. Pour plus de détails, nous vous invitons à consulter le manuel de ces outils, via les commandes man awk et man sed

Cet exemple ne recherche pas à être spécialement optimisé, mais plutôt à montrer quelques possibilités illustrées par l’utilisation combinée de BASH et de TORQUE.
Dans un cas réel, vous serez amené(e) à optimiser vos scripts afin d’en diminuer le coût, en termes de temps d’exécution et de ressources de stockage consommées.

Script SHELL «calc» :

Script TORQUE «requete» :

Fichier de paramètres «para.in» :

Le principe est le suivant :

Le script SHELL «calc» effectue une boucle, qui à chaque itération va modifier un script TORQUE de base, puis soumettre la requête correspondante.
Si vous souhaitez vous faire la main avec cet exemple, commencez par créer les trois fichiers «calc», «requete» et «para.in», dans le même répertoire, et autorisez l’exécution de «calc» avec la commande :

chmod +x calc

Pour démarrer la séquence, il vous suffit alors d’exécuter la commande :

./calc

La succession des opérations réalisées par l’interpréteur de commande BASH suite à l’exécution de «calc» est la suivante :

• #!/bin/bash : indique le langage de script et l’interpréteur de commandes utilisé - ici, il s’agit d’un script BASH

• para=para.in : définition d’une variable contenant le nom du fichier de paramètres, nommé ici «para.in». Il contient les différentes valeurs souhaitées pour le paramètre n, une par ligne

• nl=`awk 'END {print NR}' $para` : lecture du nombre de calculs souhaités à l’aide du programmme de traitement de lignes awk

• for ((i=1;i<=$nl;i+=1));do : début de la boucle

•        n=`awk -v l=$i 'NR==l{print $1}' $para` : affectation de la variable n à partir du fichier de paramètres, à l’aide de la commande awk. L’option '-v l=$i' permet d’utiliser la variable de la boucle, notée 'i', dans la commande awk

•        nom_rep=`printf "%.1f" $n` : définition d’un nom de répertoire pour le résultat du calcul correspondant à la valeur du paramètre utilisée

•        mkdir "$nom_rep" : création du répertoire

•        cp requete "$nom_rep/" : copie de la requête, correspondant à un script TORQUE, dans le nouveau répertoire

•        cd "$nom_rep/" : changement du répertoire courant, qui devient le nouveau répertoire

•        sed -i 's/nom_requete/'"add$n"'/' requête : modification du script TORQUE, pour affecter la variable nvar à la valeur choisie. Le principe est le même que celui exposé dans la première partie de ce document. Le programme bc est utilisé, permettant des calculs décimaux. La commande time permet de connaître la durée de chaque processus, enregistré dans le fichier d’erreur «nom_requete.err»

•        sed -i 's/nvar/'"$n"'/g' requête : définition d’un nom de requête associé à la valeur choisie

•        qsub requête : soumission de la requête à TORQUE

•        cd .. : retour au répertoire initial

• done : fin de la boucle

• exit 0 : fin du script. Renvoi de la valeur 0 pour indiquer que les soumissions sont arrivées à terme.

Une fois exécutée la commande ./calc, regardez l’état des «jobs» TORQUE ’add1’, ’add2’, ’add3’,’add4’ et ’add5’ précédents en exécutant la commande :

qstat

Si, avec la commande qstat -f, vous regardez plus en détails l’exécution de ces «jobs», vous vous apercevrez qu’ils ont été exécutés en parallèle, sur des cœurs différents du même nœud d’exécution.

Documentations

Toutes les commandes TORQUE possèdent un manuel accessible par la commande man, exemple :

man qsub

Vous retrouverez aussi ces informations dans la documentation en ligne suivante :

http://docs.adaptivecomputing.com/torque/4-2-9/help.htm#topics/12-appendices/commandsOverview.htm

Vous trouverez la liste des variables d’environnement TORQUE, utilisables dans les scripts TORQUE, dans la documentation en ligne suivante :

http://docs.adaptivecomputing.com/torque/4-2-9/help.htm#topics/2-jobs/exportedBatchEnvVar.htm

De plus, les documentations précédentes sont tirées de la documentation technique de référence de TORQUE qui est disponible à l’adresse suivante :

http://docs.adaptivecomputing.com/torque/4-2-9/help.htm

Enfin, considérez aussi que TORQUE est utilisé par toute une communauté et n’hésitez pas à vous inspirer des exemples d’utilisation, que vous ne manquerez pas de trouver sur l’Internet.