BqTools

De Wiki de Calcul Québec
Aller à : Navigation, rechercher
Cette page contient des modifications qui ne sont pas marquées pour la traduction.

Autres langues :anglais 100% • ‎français 100%

Sommaire

Description

Les BQTools (Batch Queueing Tools) ont été développés afin de simplifier la soumission d'un grand nombre de tâches sur une grappe de calcul. Cet outil ne fait pas la soumission directement, il fait appel au gestionnaire de tâches Torque pour cela.

Son avantage consiste en le fait de pouvoir générer un très grand nombre de tâches et de gérer automatiquement les répertoires d'exécution, d'offir le pré et post-traitement de chaque tâche ou de l'ensemble des tâches. La figure qui suit illustre ce que fait BQTools. Référez-vous aux sections suivantes pour apprendre à l'utiliser.

Chaque groupe de tâches est appelé un paquet ("batch"). Il reçoit son propre identifiant (batchId). L'usager peut recupérer de l'information sur le paquet ou détruire un paquet au complet en utilisant cet identifiant. Puisque bqtools est bâti sur Torque, chaque tâche appartenant à un paquet reçoit son propre identifiant (jobId). L'usager peut obtenir de l'information sur une tâche précise en utilisant cet identifiant. Pour plus d'information voir la documentation sur Torque.

Bqtools.png

Avantages et inconvénients

Pour vous permettre de choisir si vous devriez utiliser les BQTools voici un comparatif avec les PBS-Array.

Avantages
  • Gestion automatique des fichiers.
  • Possibilité de soumettre d'un coup un très grand nombre de tâches.
  • Simplicité pour resoumettre les jobs qui ne sont pas complétées.
  • Simplicité pour lire les paramètres d'un fichier
  • Simplicité pour gérer les batch à plusieurs paramètres
  • Simplicité pour gérer des post-traitement
  • Simplicité pour gérer la batch ou chaque job séparément (détruire,...)
  • Accumulation de tâches pour remplir des noeuds avec des tâches série
  • Permet de facilement grouper des petites tâches en une seule tâche et ainsi de réduire le temps d'attente en queue.
Inconvénients
  • Moins répandu que les PBS-Array
  • Un peu plus long à apprendre

En résumé, les BQTools sont un peu plus compliqués que les PBS-Array mais offrent plus de fonctionalités. Certaines des fonctionalités des BQTools peuvent être obtenues avec les PBS-Array, mais avec beaucoup plus d'effort (de codage).

Commandes

bqsub

Usage : bqsub [-P clé=valeur][options qsub]

Soumet un script ou une commande. bqsub est bâti sur la commande bqsubmit de BQTools, mais ne requiert pas de fichier de configuration. Elle accepte toutes les options de la commande qsub de Torque. Utilisez cette commande lorsque vous ne soumettez qu'une tâche.
Options :
-P clé=valeur : donne une paire clé/valeur pour BQTools (les clés peuvent être command ou applicationType);
options qsub : par exemple, -l walltime=hh:mm:ss,nodes=nodes:ppn=ppn -q destination.
Voir la documentation de Torque pour plus de details.

bqdel

Usage : bqdel jobId

Retire la tâche jobId du système. Utilisez bqstat si vous voulez connaître le jobId d'une tâche.

bqstat

Usage : bqstat [options qstat]

Retourne l'état des tâches sur le système.
Options :
-q destination : affiche l'état d'une file d'attente;
-u username : affiche l'état des tâches d'un utilisateur particulier;
-f jobId : affiche plus de détails sur l'état de la tâche jobId.

bqsubmit

Usage : bqsubmit [-x] [-P clé=valeur] [configurationFile]

Pour soumettre un paquet de tâches.
Options :
-x : crée l'ensemble des répertoires pour la soumission des tâches, mais ne les soumet pas;
-P clé=valeur : modifie ou ajoute une paire clé/valeur à celles qui se trouvent dans le fichier de configuration;
configurationFile : nom du fichier de configuration. Par défaut, le fichier bqsubmit.dat sera utilisé.

bqdelete

Usage : bqdelete [batchId]

Retire toutes les tâches associées à un paquet. Pour connaître le batchId associé à votre paquet, utilisez bqstatus ou le nom du fichier .status créé dans le répertoire (batchName_batchId.status).
Si aucun paquet n'est spécifié, la commande affichera la liste des paquets soumis.

bqstatus

Usage : bqstatus [batchId]

Affiche l'état des paquets soumis avec la commande bqsubmit. Si un paquet particulier est indiqué, la commande donne l'état des tâches de ce paquet.
Notez qu'en cas de problème, le résultat peut être différent de celui de qstat car bqstatus n'interroge pas Torque, mais explore la liste des fichiers créés.

bqmon

Usage : bqmon [-u user]

Affiche l'utilisation du système. Si un utilisateur est spécifié, indique la liste des nœuds occupés par les tâches de l'utilisateur.

bqconcurrentjobs

Usage : bqconcurrentjobs [batchId valeur]

Affiche le nombre de tâches pouvant être exécutées en même temps pour chaque paquet soumis. Si un paquet particulier et une valeur est indiquée, la commande modifie le nombre possible de tâches exécutées en même temps à la valeur indiquée.

Fichier de configuration

Le fichier de configuration est ce qui permet de construire vos paquets de tâches. La première fois que vous en écrirai un, ça requerra un peu plus de travail, mais il sera beaucoup plus rapide de soumettre un grand nombre de tâches. Si vous avez besoin d'aide contacter l'équipe technique de Calcul Québec.

Il y a plusieurs mots clés qui vous serviront à construire votre fichier de configuration. Nous décrivons les mots clés dans les sections qui suivent. Vous trouverez également des exemples de fichiers de configuration ci-dessous.

Mots clés requis

command
Indique la commande à exécuter sur chacun des nœuds de calcul.

Mots clés optionnels

batchName
Nom du paquet de tâches. Ce nom ne peut être utilisé pour plus d'un paquet dans un même répertoire de travail. Voir la section sur la resoumission.
applicationType
Spécifie le type d'application. La seule option est mpi. Lorsque vous utilisez cette option, vous n'avez pas à mettre mpirun -n np dans la commande, mais uniquement le nom de l'exécutable.
submitOptions
Spécifie les ressources requises par chaque tâche.
copyFiles
Liste des fichiers qui doivent être copiés pour chaque tâche (ne doit pas être de très grande taille).
linkFiles
Liste des très gros fichiers ou des répertoires qui doivent être accessibles à chaque tâche.
templateFiles
Liste des fichiers dont le contenu varie d'une tâche à une autre. Il faut rempalcer les variables par le nom des paramètres utilisés pour les représenter. Voir la section sur « Syntaxe des paramètres » pour plus d'information.
preBatch
Commande exécutée sur le nœud interactif dans le répertoire de soumission des tâches. Celle-ci est exécutée une seule fois, avant l'ensemble des tâches.
preJob
Commande exécutée sur le nœud interactif dans le répertoire de la tâche. Cette commande est exécutée indépendamment pour chaque tâche.
postJob
Commande exécutée par le nœud interactif dans le répertoire de la tâche. Cette commande est exécutée après l'exécution de chaque tâche individuellement.
postBatch
Commande exécutée par le nœud interactif dans le répertoire de soumission des tâches. Elle est exécutée une seule fois pour toutes les tâches.
paramSymLinks
1 ou 0 déterminant si l'on veut ou pas la création de liens symboliques vers chacun des répertoires d'exécution des tâches. Les noms de ces liens sont plus explicites que le nom des répertoires, car ils contiennent les paramètres et leur valeurs. Par défaut : 1.
concurrentJobs
Détermine le nombre de tâches (ou groupe de tâches) pouvant être exécutées en même temps. Si une tâche requiert que la tâche précédente soit complétée avant de pouvoir être exécutée, il suffit de mettre cette valeur à 1.

Mots clés spécifiques à Mp2

runJobsPerNode = nombre
Indique le nombre de tâches pouvant être exécutées en même temps sur un même nœud. Par défaut, ce nombre est égal au nombre de cœurs. Si chaque tâche est parallélisé avec OpenMP et que runJobsPerNode est supérieur à 1, n'oubliez pas d'ajuster la valeur de OMP_NUM_THREADS dans votre commande.
accJobsPerNode = nombre
Pour ajuster le nombre de tâches soumises sur chaque nœud. Ce nombre devrait être un multiple du nombre runJobsPerNode. Par exemple, si accJobsPerNode est égal à deux fois la valeur de runJobsPerNode, il y aura runJobsPerNode tâches exécutées et lorsque celles-ci seront terminées, un autre groupe de runJobsPerNode tâches seront exécutées. Notez que le "walltime" indiqué dans la variable "submitOptions" doit être suffisant pour couvrir les deux groupes de tâches. Cette option est utile lorsqu'il y a un très grands nombres de tâches très courtes. Par défaut, la valeur de accJobsPerNode est égal au nombre de cœurs par nœud.

Mots clés spécifiques à Ms2

microJobs = nombre
Permet de regrouper les tâches en groupe de nombre tâches. Chacune de ces tâches sera exécutée l'une après l'autre sur les mêmes cœurs.
Les ressources indiquées dans submitOptions doivent être suffisantes pour tout le groupe. En particulier la ressource walltime.

Syntaxe des paramètres

Il y a plusieurs façons de déterminer le jeu des paramètres : deux paramètres peuvent être reliés et faire partie d'une boucle unique, un paramètre peut être fixe, etc. Dans les sections qui suivent vous trouverez quelle est la syntaxe à utiliser.

Paramètre constant

Ex : temperature = 10

Paramètres avec une liste de valeurs

Ex : param1 = temperature = [10, 11, 14, 15]

Boucle simple avec une variable

Ex : param1 = temperature = 10 : 1 : 15
Usage : param1 = token = startValue : increment : stopValue

Boucle simple à plusieurs variables

Ex : param1 = (temperature, pression) = [(10:1:15, 100:1:105)]
Il est également possible d'avoir des listes de valeurs avec plus d'une variables.
Ex : param1 = (temperature, pression) = [(10,100), (11,101), (12,102), (13,103), (14,104), (15,105)]

Boucles multiples

Ex : param1 = temperature = 10 : 1 : 15

param2 = pression = [101, 102]

Dans ce cas-ci, nous avons six valeurs différentes de température et deux valeurs de pression, pour un total de 6*2 = 12 cas.

Boucle déterminée par un fichier

Ex : param1 = (temperature, pression) = load param.txt
Notez que le nombre de colonnes dans le fichier param.txt doit être égal au nombre de variables dans le paramètre. Chaque colonne doit être séparée par une espace ou par une virgule. Le fichier peut également contenir des lignes blanches et des lignes de commentaires (débute par un #). Ces lignes seront simplement ignorées lors de la lecture du fichier. Pour notre exemple, le fichier ressemblerait à ceci :

# temperature pression
    10.         101.
    10.         102.
    11.         101.
    11.         102.
    12.         101.
    12.         102.
    13.         101.
    13.         102.


Exemple pour Ms2

Considérons le cas d'une tâche parallèle OpenMP et que l'on veut utiliser quatre fils pour chaque tâche. Supposons que l'on a 100 tâches et que chacune requiert moins d'une heure pour s'exécuter. Nous les accumulerons en groupe de cinq tâches. Le fichier de configuration des BQTools ressemblerait à ceci :

Fichier : bqsubmit.dat
# Nom du paquet
batchName = casMultifils
 
# Fichier binaire à exécuter
copyFiles = my_exec
 
# Fichier d'entrée contenant la valeur des variables
templateFiles = input.txt
 
# tâche à exécuter avant de soumettre les tâches sur le système
preBatch = rm -f totalOutput.txt
 
# Commande à exécuter sur le nœud de calcul
command = export OMP_NUM_THREADS=4; ./my_exec input.txt > output.txt
 
# Rassemblement des résultats dans un fichier unique
postBatch = cat *.BQ/*.BQ/output.txt >> totalOutput.txt
 
# On ne veut pas de lien symbolique
paramSymLinks = 0
 
# Rassemblement des tâches par groupes de cinq
microJobs = 5
 
# Ressource requise par chaque groupe de cinq tâches.
submitOptions = -q qwork@ms -l walltime=5:00:00,nodes=1:ppn=4
 
# Liste des paramètres pour chaque tâche
param1 = (temperature, pression) = load values.txt
 
# Combien de groupes de cinq tâches peuvent être exécutés en même temps.
concurrentJobs = 20


Le répertoire de travail devrait contenir quatre fichiers avant la soumission des tâches :

bqsubmit.dat
Le fichier de configuration de BQTools tel que décrit ci-dessus.
my_exec
binaire pour l'execution des tâches.
values.txt
fichier texte contenant deux colonnes : la première est la température et la deuxième la pression pour chaque tâche. Le fichier contient donc 100 lignes sans compter les lignes de commentaires et les lignes blanches. Le fichier ressemblera à ceci:
# Temperature (Celsius) Pression (KPa)
 10. 99.0
 11. 99.0
 12. 99.0
 13. 99.0
 14. 99.0
 15. 99.0
 10. 99.2
 11. 99.2
 ....
input.txt
Le fichier lu par l'exécutable. Il faut remplacer la valeur des clés par leur nom entouré des symboles "~~". BQTools se charge de remplacer ces noms par les valeurs appropriées pour chaque tâche. Le fichier devrait ressembler à ce qui suit :
temparature = ~~temperature~~
pression = ~~pression~~

Exemple pour Mp2

Considérons un cas hybride cette fois. Puisque Mp2 contient beaucoup de cœurs pour chaque carte InfiniBand, il est plus performant d'exécuter des codes hybrides sur ce système.

Supposons que l'on veut soumettre 400 tâches et que pour chaque tâche hybride nous aurons quatre processus MPI et trois fils pour chaque processus. Nous pouvons déduire que chaque tâche aura besoin de 12 cœurs. Ainsi, nous pouvons soumettre deux tâches par nœud (runJobsPerNode = 2). Supposons que chaque tâche requiert moins de deux heures pour s'exécuter et que nous voulons exécuter deux tâches l'une après l'autre sur les mêmes cœurs. Finalement, nous considérons que ce qui changera d'une tâche à une autre sera le fichier d'entrée utilisé. Supposons que votre fichier exécutable (mon_bin) se trouve dans un répertoire accessible via la variable d'environnement $PATH. Votre répertoire de travail contient les éléments suivants :

bqsubmit.dat
Le fichier de configuration pour la soumission des tâches. Nous décrirons son contenu plus tard.
mesCas
Un répertoire qui contient les fichiers d'entrée pour chaque cas que vous voulez exécuter. Pour les 400 tâches d'intérêt, ce répertoire devrait contenir 400 fichiers différents.
executeTache.sh
Un script pour le lancement des tâches. Le contenu de ce fichier devrait ressembler à ceci :
#!/bin/bash
module load openmpi_intel64/1.4.3_ofed
export OMP_NUM_THREADS=3
mpirun -n 4 mon_bin ~~input~~

Le fichier de configuration des tâches (bqsubmit.dat) devrait donc être similaire à ceci :

Fichier : bqsubmit.dat
# Nom du paquet
batchName = casHybride
 
# Fichier de soumission des tâches
templateFiles = executeTache.sh
 
# Lien pour accéder aux fichiers d'entrée
linkFiles = mesCas
 
# Commande à exécuter sur le nœud de calcul
command = /bin/bash executeTache.sh
 
# Combien de tâches par nœud en même temps
runJobsPerNode = 2
 
# Combien de tâches seront soumises sur un même nœud
accJobsPerNode = 4
 
# Ressources requises par chaque groupe de quatre tâches.
submitOptions = -q qwork@mp2 -l walltime=4:00:00,nodes=1
 
# Liste des paramètres pour chaque tâche
param1 = input = load listInput.txt
 
# Combien de groupe de quatre tâches peuvent être exécutés en même temps.
concurrentJobs = 100


Avant de pouvoir soumettre ces tâches, vous devrez créer le fichier listInput.txt définissant l'ensemble des tâches que vous voulez soumettre. Vous pouvez le créer très rapidement, simplement en entrant la commande suivante dans un interpréteur de commandes, après vous être placé dans le répertoire de travail :

[nom@serveur $] ls -1 mesCas/* >& listInput.txt


Resoumission de tâches

Pour protéger vos résultats, BQTools n'autorise pas de resoumettre un paquet dans un même répertoire. Toutefois, il y a diverses raisons pour lesquels on voudrait resoumettre un paquet de tâches. La façon appropriée de le faire dépend des circonstances qui s'appliquent à vous. On distingue trois raisons principales pour lesquelles vous pourriez vouloir resoumettre votre paquet.

  1. Il y a des tâches qui ne se sont pas bien complétées, mais certains résultats sont corrects. Il suffit de s'assurer qu'il n'y a pas de fichiers « .bqdone » dans les cas à resoumettre et exécuter la commande bqsubmit. En effet, le fichier .bqdone créé par BQTools dans les dossiers de plus haut niveaux, sert à indiquer les tâches qui ont été complétées avec succès. Toutefois, ce que BqTools considère être un succès ne l'est pas forcément pour vous. Vous aurez possiblement à détruire des fichiers .bqdone.
  2. Aucun résultat ne sont bons, il faut tout resoumettre : effacez tous les répertoires créés par BQTools (rm -r *.BQ) et resoumettez la tâche après avoir fait les correctifs nécessaires.
  3. Tous les résultats sont bons, mais vous voulez resoumettre des cas différents et ce dans le même répertoire de travail : changez la valeur de batchName dans votre fichier de configuration et soumettez le nouveau paquet.
Outils personnels
Espaces de noms

Variantes
Actions
Navigation
Ressources de Calcul Québec
Outils
Partager