Abaqus
Abaqus FEA est un progiciel commercial pour l'analyse d'éléments finis et l'ingénierie assistée par ordinateur.
Votre licence
Des modules Abaqus sont disponibles sur nos grappes, mais vous devez posséder votre propre licence. Pour configurer votre compte sur les grappes que vous voulez utiliser, connectez-vous et créez sur chacune un fichier $HOME/.licenses/abaqus.lic qui contient les deux lignes suivantes, pour les versions 202X et 6.14.1 respectivement. Remplacez ensuite port@server par le numéro du port flexlm et l'adresse IP (ou le nom complet du domaine) de votre serveur de licence Abaqus.
prepend_path("ABAQUSLM_LICENSE_FILE","port@server")
prepend_path("LM_LICENSE_FILE","port@server")
Si votre licence n'est pas configurée pour une grappe en particulier, les administrateurs de systèmes des deux parties devront effectuer certaines modifications. Ceci est nécessaire pour que les ports flexlm et TCP de votre serveur Abaqus puissent être rejoints par tous les nœuds de calcul quand vos tâches dans la queue seront exécutées. Pour que nous puissions vous assister dans cette tâche, écrivez au soutien technique en indiquant
- le numéro du port flexlm
- le numéro du port statique
- l'adresse IP de votre serveur de licence Abaqus.
En retour vous recevrez une liste d'adresses IP et votre administrateur de système pourra ouvrir les pare-feu de votre serveur local pour que la grappe puisse se connecter via les deux ports. Une entente spéciale doit habituellement être négociée et signée avec SIMULIA pour qu'une telle licence puisse être utilisée à distance avec notre matériel.
Soumettre une tâche
Vous trouverez ci-dessous des prototypes de scripts Slurm pour soumettre des simulations parallèles sur un ou plusieurs nœuds de calcul en utilisant des fils et MPI. Dans la plupart des cas, il suffira d'utiliser un des scripts du répertoire /project dans une des sections pour un nœud simple. Dans la dernière ligne des scripts, l'argument memory= est optionnel et sert aux tâches qui demandent beaucoup de mémoire ou qui posent problème; la valeur de déplacement de 3072Mo pourrait nécessiter un ajustement. Pour obtenir la liste des arguments en ligne de commande, chargez un module Abaqus et lancez abaqus -help | less.
Pour une tâche sur un nœud simple d'une durée de moins de 24 heures, le script du répertoire /project sous le premier onglet devrait suffire. Pour une tâche de plus longue durée, utilisez un script de redémarrage.
Il est préférable que les tâches qui créent des fichiers de redémarrage volumineux écrivent sur le disque local via l'utilisation de la variable d'environnement SLURM_TMPDIR utilisée dans les scripts de répertoire temporaire sous les deux onglets les plus à droite des sections d'analyse standard et explicite à nœud unique. Les scripts de redémarrage présentés ici poursuivront les tâches qui ont été interrompues prématurément pour une quelconque raison. De telles interruptions peuvent se produire si une tâche atteint son temps d'exécution maximal demandé avant de se terminer et est arrêtée par la file d'attente ou si le nœud de calcul sur lequel la tâche était exécutée a planté en raison d'une défaillance matérielle inattendue. D'autres types de redémarrage sont possibles en modifiant davantage le fichier d'entrée (non montré) pour continuer une tâche avec des étapes supplémentaires ou modifier l'analyse (consultez la documentation pour plus de détails pour la version).
Les tâches qui exigent beaucoup de mémoire ou beaucoup de ressources de calcul (plus que la capacité d'un nœud simple) devraient utiliser les scripts MPI dans les sections pour nœuds multiples afin de distribuer le calcul sur un ensemble de nœuds arbitraires déterminé automatiquement par l'ordonnanceur. Avant de lancer des tâches de longue durée, il est recommandé d'exécuter de courts tests présentant peu de scalabilité pour déterminer la durée réelle d'exécution (et les exigences en mémoire) en fonction du nombre optimal de cœurs (2, 4, 8, etc.).
Analyse standard
Les solveurs prennent en charge la parallélisation avec fils et avec MPI. Des scripts pour chaque mode sont présentés sous les onglets pour l'utilisation d'un nœud simple et celle de nœuds multiples. Des scripts pour redémarrer une tâche qui utilise des nœuds multiples ne sont pas présentés pour l'instant.
Scripts pour un nœud simple
#!/bin/bash
#SBATCH --account=def-group # Specify account
#SBATCH --time=00-06:00 # Specify days-hrs:mins
#SBATCH --cpus-per-task=4 # Specify number of cores
#SBATCH --mem=8G # Specify total memory > 5G
#SBATCH --nodes=1 # Do not change !
##SBATCH --constraint=cascade # Uncomment to specify node (cpu/gpu jobs)
##SBATCH --gres=gpu:t4:1 # Uncomment to specify gpu
# or
##SBATCH --constraint=rome # Uncomment to specify node (gpu only jobs)
##SBATCH --gres=gpu:a100:1 # Uncomment to specify gpu
module load StdEnv/2020 # Latest installed version
module load abaqus/2021 # Latest installed version
#module load StdEnv/2016 # Uncomment to use
#module load abaqus/2020 # Uncomment to use
unset SLURM_GTIDS
export MPI_IC_ORDER='tcp'
echo "LM_LICENSE_FILE=$LM_LICENSE_FILE"
echo "ABAQUSLM_LICENSE_FILE=$ABAQUSLM_LICENSE_FILE"
rm -f testsp1* testsp2*
abaqus job=testsp1 input=mystd-sim.inp \
scratch=$SLURM_TMPDIR cpus=$SLURM_CPUS_ON_NODE interactive \
mp_mode=threads memory="$((${SLURM_MEM_PER_NODE}-3072))MB" \
# gpus=$SLURM_GPUS_ON_NODE # uncomment this line to use gpu
Pour écrire les données de redémarrage en incréments de N=12, le fichier en entrée doit contenir
*RESTART, WRITE, OVERLAY, FREQUENCY=12
Pour écrire les données de redémarrage pour un total de 12 incréments, entrez plutôt
*RESTART, WRITE, OVERLAY, NUMBER INTERVAL=12, TIME MARKS=NO
Pour vérifier l'information complète sur le redémarrage
egrep -i "step|start" testsp*.com testsp*.msg testsp*.sta
Certaines simulations peuvent être améliorées en ajoutant au bas du script la commande Abaqus
order_parallel=OFF
#!/bin/bash
#SBATCH --account=def-group # Specify account
#SBATCH --time=00-06:00 # Specify days-hrs:mins
#SBATCH --cpus-per-task=4 # Specify number of cores
#SBATCH --mem=8G # Specify total memory > 5G
#SBATCH --nodes=1 # Do not change !
##SBATCH --constraint=cascade # Uncomment to specify node (44cores)
##SBATCH --gres=gpu:t4:1 # Uncomment to specify gpu
# or
##SBATCH --constraint=rome # Uncomment to specify node (128cores)
##SBATCH --gres=gpu:a100:1 # Uncomment to specify gpu
module load StdEnv/2020 # Latest installed version
module load abaqus/2021 # Latest installed version
unset SLURM_GTIDS
export MPI_IC_ORDER='tcp'
echo "LM_LICENSE_FILE=$LM_LICENSE_FILE"
echo "ABAQUSLM_LICENSE_FILE=$ABAQUSLM_LICENSE_FILE"
rm -f testsp2* testsp1.lck
abaqus job=testsp2 oldjob=testsp1 input=mystd-sim-restart.inp \
scratch=$SLURM_TMPDIR cpus=$SLURM_CPUS_ON_NODE interactive \
mp_mode=threads memory="$((${SLURM_MEM_PER_NODE}-3072))MB" \
# gpus=$SLURM_GPUS_ON_NODE # uncomment this line to use gpu
Le fichier en entrée pour le redémarrage doit contenir
*HEADING *RESTART, READ
#!/bin/bash
#SBATCH --account=def-group # Specify account
#SBATCH --time=00-06:00 # Specify days-hrs:mins
#SBATCH --cpus-per-task=4 # Specify number of cores
#SBATCH --mem=8G # Specify total memory > 5G
#SBATCH --nodes=1 # Do not change !
##SBATCH --constraint=cascade # Uncomment to specify node (cpu/gpu jobs)
##SBATCH --gres=gpu:t4:1 # Uncomment to specify gpu
# or
##SBATCH --constraint=rome # Uncomment to specify node (gpu only jobs)
##SBATCH --gres=gpu:a100:1 # Uncomment to specify gpu
module load StdEnv/2020 # Latest installed version
module load abaqus/2021 # Latest installed version
unset SLURM_GTIDS
export MPI_IC_ORDER='tcp'
echo "LM_LICENSE_FILE=$LM_LICENSE_FILE"
echo "ABAQUSLM_LICENSE_FILE=$ABAQUSLM_LICENSE_FILE"
echo "SLURM_SUBMIT_DIR =" $SLURM_SUBMIT_DIR
echo "SLURM_TMPDIR = " $SLURM_TMPDIR
rm -f testst1* testst2*
mkdir $SLURM_TMPDIR/scratch
cd $SLURM_TMPDIR
while sleep 6h; do
echo "Saving data due to time limit ..."
cp -fv * $SLURM_SUBMIT_DIR 2>/dev/null
done &
WPID=$!
abaqus job=testst1 input=$SLURM_SUBMIT_DIR/mystd-sim.inp \
scratch=$SLURM_TMPDIR/scratch cpus=$SLURM_CPUS_ON_NODE interactive \
mp_mode=threads memory="$((${SLURM_MEM_PER_NODE}-3072))MB" \
# gpus=$SLURM_GPUS_ON_NODE # uncomment this line to use gpu
{ kill $WPID && wait $WPID; } 2>/dev/null
cp -fv * $SLURM_SUBMIT_DIR
Pour écrire les données de redémarrage en incréments de N=12, le fichier en entrée doit contenir
*RESTART, WRITE, OVERLAY, FREQUENCY=12
Pour écrire les données de redémarrage pour un total de 12 incréments, entrez plutôt
*RESTART, WRITE, OVERLAY, NUMBER INTERVAL=12, TIME MARKS=NO
Pour vérifier l'information complète sur le redémarrage
egrep -i "step|start" testst*.com testst*.msg testst*.sta
#!/bin/bash
#SBATCH --account=def-group # Specify account
#SBATCH --time=00-06:00 # Specify days-hrs:mins
#SBATCH --cpus-per-task=4 # Specify number of cores
#SBATCH --mem=8G # Specify total memory > 5G
#SBATCH --nodes=1 # Do not change !
##SBATCH --constraint=cascade # Uncomment to specify node (44 cores)
##SBATCH --gres=gpu:t4:1 # Uncomment to specify gpu
# or
##SBATCH --constraint=rome # Uncomment to specify node (128 cores)
##SBATCH --gres=gpu:a100:1 # Uncomment to specify gpu
module load StdEnv/2020 # Latest installed version
module load abaqus/2021 # Latest installed version
unset SLURM_GTIDS
export MPI_IC_ORDER='tcp'
echo "LM_LICENSE_FILE=$LM_LICENSE_FILE"
echo "ABAQUSLM_LICENSE_FILE=$ABAQUSLM_LICENSE_FILE"
echo "SLURM_SUBMIT_DIR =" $SLURM_SUBMIT_DIR
echo "SLURM_TMPDIR = " $SLURM_TMPDIR
rm -f testst2* testst1.lck
cp testst1* $SLURM_TMPDIR
mkdir $SLURM_TMPDIR/scratch
cd $SLURM_TMPDIR
while sleep 6h; do
echo "Saving data due to time limit ..."
cp -fv testst2* $SLURM_SUBMIT_DIR 2>/dev/null
done &
WPID=$!
abaqus job=testst2 oldjob=testst1 input=$SLURM_SUBMIT_DIR/mystd-sim-restart.inp \
scratch=$SLURM_TMPDIR/scratch cpus=$SLURM_CPUS_ON_NODE interactive \
mp_mode=threads memory="$((${SLURM_MEM_PER_NODE}-3072))MB" \
# gpus=$SLURM_GPUS_ON_NODE # uncomment this line to use gpu
{ kill $WPID && wait $WPID; } 2>/dev/null
cp -fv testst2* $SLURM_SUBMIT_DIR
Le fichier en entrée pour le redémarrage doit contenir
*HEADING *RESTART, READ
Script pour nœuds multiples
Si vous disposez d'une licence qui vous permet d'exécuter des tâches nécessitant beaucoup de mémoire et de calcul, le script suivant pourra effectuer le calcul avec MPI en utilisant un ensemble de nœuds arbitraires idéalement déterminé automatiquement par l'ordonnanceur. Un script modèle pour redémarrer des tâches sur nœuds multiples n'est pas fourni car son utilisation présente des limitations supplémentaires.
!/bin/bash
#SBATCH --account=def-group # Specify account
#SBATCH --time=00-06:00 # Specify days-hrs:mins
##SBATCH --nodes=2 # Uncomment to specify (optional)
#SBATCH --ntasks=8 # Specify number of cores
#SBATCH --mem-per-cpu=4G # Specify memory per core
##SBATCH --tasks-per-node=4 # Uncomment to specify (optional)
#SBATCH --cpus-per-task=1 # Do not change !
module load StdEnv/2020 # Latest installed version
module load abaqus/2021 # Latest installed version
unset SLURM_GTIDS
#export MPI_IC_ORDER='tcp'
echo "LM_LICENSE_FILE=$LM_LICENSE_FILE"
echo "ABAQUSLM_LICENSE_FILE=$ABAQUSLM_LICENSE_FILE"
rm -f testsp1-mpi*
unset hostlist
nodes="$(slurm_hl2hl.py --format MPIHOSTLIST | xargs)"
for i in `echo "$nodes" | xargs -n1 | uniq`; do hostlist=${hostlist}$(echo "['${i}',$(echo "$nodes" | xargs -n1 | grep $i | wc -l)],"); done
hostlist="$(echo "$hostlist" | sed 's/,$//g')"
mphostlist="mp_host_list=[$(echo "$hostlist")]"
export $mphostlist
echo "$mphostlist" > abaqus_v6.env
abaqus job=testsp1-mpi input=mystd-sim.inp \
scratch=$SLURM_TMPDIR cpus=$SLURM_NTASKS interactive mp_mode=mpi \
#mp_host_split=1 # number of dmp processes per node >= 1 (uncomment to specify)
Analyse explicite
Les solveurs prennent en charge la parallélisation avec fils et avec MPI. Des scripts pour chaque mode sont présentés sous les onglets pour l'utilisation d'un nœud simple et celle de nœuds multiples. Des modèles de scripts pour redémarrer une tâche qui utilise des nœuds multiples nécessitent plus de tests et ne sont pas présentés pour l'instant.
Scripts pour un nœud simple
#!/bin/bash
#SBATCH --account=def-group # indiquer le nom du compte
#SBATCH --time=00-06:00 # indiquer la limite de temps (jours-heures:minutes)
#SBATCH --mem=8000M # indiquer la mémoire totale > 5M
#SBATCH --cpus-per-task=4 # indiquer le nombre de cœurs > 1
#SBATCH --nodes=1 # ne pas modifier
module load StdEnv/2020
module load abaqus/2021
unset SLURM_GTIDS
export MPI_IC_ORDER='tcp'
echo "LM_LICENSE_FILE=$LM_LICENSE_FILE"
echo "ABAQUSLM_LICENSE_FILE=$ABAQUSLM_LICENSE_FILE"
rm -f testep1* testep2*
abaqus job=testep1 input=myexp-sim.inp \
scratch=$SLURM_TMPDIR cpus=$SLURM_CPUS_ON_NODE interactive \
mp_mode=threads memory="$((${SLURM_MEM_PER_NODE}-3072))MB"
Pour écrire les données de redémarrage pour un total de 12 incréments, le fichier en entrée doit contenir
*RESTART, WRITE, OVERLAY, NUMBER INTERVAL=12, TIME MARKS=NO
Pour vérifier l'information complète sur le redémarrage
egrep -i "step|restart" testep*.com testep*.msg testep*.sta
#!/bin/bash
#SBATCH --account=def-group # indiquer le nom du compte
#SBATCH --time=00-06:00 # indiquer la limite de temps (jours-heures:minutes)
#SBATCH --mem=8000M # indiquer la mémoire totale > 5M
#SBATCH --cpus-per-task=4 # indiquer le nombre de cœurs > 1
#SBATCH --nodes=1 # ne pas modifier
module load StdEnv/2020
module load abaqus/2021
unset SLURM_GTIDS
export MPI_IC_ORDER='tcp'
echo "LM_LICENSE_FILE=$LM_LICENSE_FILE"
echo "ABAQUSLM_LICENSE_FILE=$ABAQUSLM_LICENSE_FILE"
rm -f testep2* testep1.lck
for f in testep1*; do [[ -f ${f} ]] && cp -a "$f" "testep2${f#testep1}"; done
abaqus job=testep2 input=myexp-sim.inp recover \
scratch=$SLURM_TMPDIR cpus=$SLURM_CPUS_ON_NODE interactive \
mp_mode=threads memory="$((${SLURM_MEM_PER_NODE}-3072))MB"
Le fichier en entrée ne requiert aucune modification pour le redémarrage de l'analyse.
#!/bin/bash
#SBATCH --account=def-group # specify account
#SBATCH --time=00-06:00 # days-hrs:mins
#SBATCH --mem=8000M # node memory > 5G
#SBATCH --cpus-per-task=4 # number cores > 1
#SBATCH --nodes=1 # do not change
module load StdEnv/2020
module load abaqus/2021
unset SLURM_GTIDS
export MPI_IC_ORDER='tcp'
echo "LM_LICENSE_FILE=$LM_LICENSE_FILE"
echo "ABAQUSLM_LICENSE_FILE=$ABAQUSLM_LICENSE_FILE"
echo "SLURM_SUBMIT_DIR =" $SLURM_SUBMIT_DIR
echo "SLURM_TMPDIR = " $SLURM_TMPDIR
rm -f testet1* testet2*
cd $SLURM_TMPDIR
while sleep 6h; do
cp -f * $SLURM_SUBMIT_DIR 2>/dev/null
done &
WPID=$!
abaqus job=testet1 input=$SLURM_SUBMIT_DIR/myexp-sim.inp \
scratch=$SLURM_TMPDIR cpus=$SLURM_CPUS_ON_NODE interactive \
mp_mode=threads memory="$((${SLURM_MEM_PER_NODE}-3072))MB"
{ kill $WPID && wait $WPID; } 2>/dev/null
cp -f * $SLURM_SUBMIT_DIR
Pour écrire les données de redémarrage pour un total de 12 incréments, le fichier en entrée doit contenir
*RESTART, WRITE, OVERLAY, NUMBER INTERVAL=12, TIME MARKS=NO
Pour vérifier l'information complète sur le redémarrage
egrep -i "step|restart" testet*.com testet*.msg testet*.sta
#!/bin/bash
#SBATCH --account=def-group # specify account
#SBATCH --time=00-06:00 # days-hrs:mins
#SBATCH --mem=8000M # node memory > 5G
#SBATCH --cpus-per-task=4 # number cores > 1
#SBATCH --nodes=1 # do not change
module load StdEnv/2020
module load abaqus/2021
unset SLURM_GTIDS
export MPI_IC_ORDER='tcp'
echo "LM_LICENSE_FILE=$LM_LICENSE_FILE"
echo "ABAQUSLM_LICENSE_FILE=$ABAQUSLM_LICENSE_FILE"
echo "SLURM_SUBMIT_DIR =" $SLURM_SUBMIT_DIR
echo "SLURM_TMPDIR = " $SLURM_TMPDIR
rm -f testet2* testet1.lck
for f in testet1*; do cp -a "$f" $SLURM_TMPDIR/"testet2${f#testet1}"; done
cd $SLURM_TMPDIR
while sleep 3h; do
cp -f * $SLURM_SUBMIT_DIR 2>/dev/null
done &
WPID=$!
abaqus job=testet2 input=$SLURM_SUBMIT_DIR/myexp-sim.inp recover \
scratch=$SLURM_TMPDIR cpus=$SLURM_CPUS_ON_NODE interactive \
mp_mode=threads memory="$((${SLURM_MEM_PER_NODE}-3072))MB"
{ kill $WPID && wait $WPID; } 2>/dev/null
cp -f * $SLURM_SUBMIT_DIR
Le fichier en entrée ne requiert aucune modification pour le redémarrage de l'analyse.
Script pour nœuds multiples
!/bin/bash
#SBATCH --account=def-group # Specify account
#SBATCH --time=00-06:00 # Specify days-hrs:mins
#SBATCH --ntasks=8 # Specify number of cores
#SBATCH --mem-per-cpu=16000M # Specify memory per core
# SBATCH --nodes=2 # Specify number of nodes (optional)
#SBATCH --cpus-per-task=1 # Do not change !
module load StdEnv/2020 # Latest installed version
module load abaqus/2021 # Latest installed version
unset SLURM_GTIDS
export MPI_IC_ORDER='tcp'
# uncomment next line when using abaqus/2021
export I_MPI_HYDRA_TOPOLIB=ipl
echo "LM_LICENSE_FILE=$LM_LICENSE_FILE"
echo "ABAQUSLM_LICENSE_FILE=$ABAQUSLM_LICENSE_FILE"
rm -f testep1-mpi*
unset hostlist
nodes="$(slurm_hl2hl.py --format MPIHOSTLIST | xargs)"
for i in `echo "$nodes" | xargs -n1 | uniq`; do hostlist=${hostlist}$(echo "['${i}',$(echo "$nodes" | xargs -n1 | grep $i | wc -l)],"); done
hostlist="$(echo "$hostlist" | sed 's/,$//g')"
mphostlist="mp_host_list=[$(echo "$hostlist")]"
export $mphostlist
echo "$mphostlist" > abaqus_v6.env
abaqus job=testep1-mpi input=myexp-sim.inp \
scratch=$SLURM_TMPDIR cpus=$SLURM_NTASKS interactive mp_mode=mpi \
#mp_host_split=1 # number of dmp processes per node >= 1 (uncomment to specify)
Estimer le besoin en termes de mémoire
Processus simple
Une estimation de la mémoire totale pour un nœud (--mem=) requise par Slurm pour qu'une simulation soit effectuée uniquement en mémoire vive (sans être virtualisée sur le disque scratch) se trouve dans le fichier de sortie Abaqus test.dat. Dans l'exemple suivant, la simulation exige une assez grande quantité de mémoire.
M E M O R Y E S T I M A T E
PROCESS FLOATING PT MINIMUM MEMORY MEMORY TO
OPERATIONS REQUIRED MINIMIZE I/O
PER ITERATION (MB) (MB)
1 1.89E+14 3612 96345
Alternativement, l'estimation de la mémoire totale pour un processus avec fils sur un nœud unique peut être obtenue en exécutant la simulation de manière interactive sur un nœud de calcul, puis en surveillant la consommation de mémoire à l'aide des commandes ps ou top. Ce qui suit décrit comment procéder dans le dernier cas :
1) Connectez-vous à une grappe aevec SSH et obtenez une allocation sur un nœud de calcul (comme gra100) et démarrez votre simulationavec :
[name@server ~]$ module load StdEnv/2020
[name@server ~]$ module load abaqus/2021
[name@server ~]$ unset SLURM_GTIDS
2) via SSH, connectez-vous de nouveau à la grappe réservée par salloc puis au nœud de calcul et lancez top.
[name@server ~]$ ssh gra100
[name@server ~]$ top -u $USER
3) observez les colonnes VIRT and RES jusqu'à ce que des valeurs de mémoire maximales stables soient atteintes.
Pour satisfaire complètement la valeur recommandée pour MEMORY TO OPERATIONS REQUIRED MINIMIZE I/O (MRMIO), au moins la même quantité de mémoire physique non échangée (RES) doit être disponible pour Abaqus. Étant donné que la RES sera en général inférieure à la mémoire virtuelle (VIRT) d'une quantité relativement constante pour une simulation donnée, il est nécessaire de surallouer légèrement la mémoire du nœud demandée -mem=. Dans l'exemple de script ci-dessus, cette surallocation a été codée en dur à une valeur prudente de 3072Mo sur la base des tests initiaux du solveur Abaqus standard. Pour éviter les longs temps d'attente associés aux valeurs élevées de MRMIO, il peut être utile d'étudier l'impact sur les performances de simulation associées à la réduction de la mémoire RES mise à disposition d'Abaqus de manière significative en dessous de la MRMIO. Cela peut être fait en diminuant la valeur de -mem= qui à son tour définira une valeur artificiellement basse de memory= dans la commande Abaqus (trouvée dans la dernière ligne du script). En faisant cela, il faut s'asssurer que RES ne descende pas en dessous de MINIMUM MEMORY REQUIRED (MMR) sinon Abaqus fermera à cause d'une mémoire insuffisante (OOM). Par exemple, si votre MRMIO est de 96Go, essayez d'exécuter une série de tâches de test courtes avec #SBATCH --mem=8G, 16G, 32G, 64G jusqu'à ce qu'un impact minimal acceptable sur les performances soit trouvé, en notant que des valeurs plus petites entraîneront un espace /scratch de plus en plus grand pour les fichiers temporaires.
Processus multiples
Pour déterminer la mémoire requise pour les scripts qui utilisent plusieurs nœuds, les estimations de mémoire (par processus de calcul) requises pour minimiser les entrées/sorties sont données dans le fichier de sortie dat pour les tâches terminées. Si mp_host_split n'est pas spécifié (ou est défini comme étant 1), le nombre total de processus de calcul sera égal au nombre de nœuds. La valeur de mem-per-cpu peut alors être déterminée approximativement en multipliant la plus grande estimation de mémoire par le nombre de nœuds, puis en divisant par le nombre de ntasks. Si toutefois la valeur de mp_host_split est spécifiée (supérieure à 1), la valeur de mem-per-cpu peut être déterminée approximativement à partir de la plus grande estimation de mémoire multipliée par le nombre de nœuds, multiplié par la valeur de mp_host_split divisée par le nombre de tâches. Notez que la valeur de mp_host_split doit être inférieure ou égale au nombre de cœurs par nœud attribué par au moment de l'exécution, sinon Abaqus s'arrêtera. Ce scénario peut être contrôlé en supprimant les commentaires pour spécifier une valeur pour les tâches par nœud. L'énoncé définitif suivant est donné dans chaque fichier dat et mentionné ici pour référence.
LE MAXIMUM DE MÉMOIRE POUVANT ÊTRE ALLOUÉ PAR ABAQUS DÉPEND EN GÉNÉRAL DE LA VALEUR DU
PARAMÈTRE MÉMOIRE ET DE LA QUANTITÉ DE MÉMOIRE PHYSIQUE DISPONIBLE SUR LA MACHINE. VEUILLEZ CONSULTER
LE MANUEL D'UTILISATION D'ABAQUS ANALYSIS POUR PLUS DE DÉTAILS. L'UTILISATION RÉELLE DE LA MÉMOIRE ET DE L'ESPACE
DISQUE POUR LES DONNÉES DE /SCRATCH DÉPENDRA DE CETTE LIMITE SUPÉRIEURE AINSI QUE DE LA MÉMOIRE REQUISE POUR
MINIMISER LES ENTRÉES/SORTIES. SI LA LIMITE SUPÉRIEURE DE MÉMOIRE EST SUPÉRIEURE À LA MÉMOIRE REQUISE POUR MINIMISER LES ENTRÉES/SORTIES, L'UTILISATION RÉELLE DE LA MÉMOIRE SERA PROCHE DE LA VALEUR ESTIMÉE DE MEMORY TO MINIMIZE I/O ET L'UTILISATION DU DISQUE DE TRAVAIL SERA PROCHE DE ZÉRO. AUTREMENT, LA MÉMOIRE RÉELLE UTILISÉE SERA PROCHE DE LA LIMITE DE MÉMOIRE
MENTIONNÉE PRÉCÉDEMMENT, ET L'UTILISATION DU DISQUE /SCRATCH SERA À PEU PRÈS PROPORTIONNELLE À LA DIFFÉRENCE
ENTRE MEMORY TO MINIMIZE I/O ESTIMÉE ET LA LIMITE SUPÉRIEURE DE LA MÉMOIRE. TOUTEFOIS, IL EST IMPOSSIBLE D'ÉVALUER AVEC PRÉCISION L'ESPACE /SCRATCH DU DISQUE.
Mode graphique
Abaqus peut être utilisé interactivement en mode graphique sur une grappe ou sur gra-vdi avec VCN.
Sur une grappe
1. Connectez-vous à un nœud de calcul (durée maximale 3 heures) avec TigerVNC.
2. Ouvrez une nouvelle fenêtre de terminal et entrez
module load StdEnv/2020 abaqus/2021
3. Lancez l'application avec
abaqus cae -mesa
Sur gra-vdi
1. Connectez-vous à un nœud VDI (durée maximale 24 heures) avec TigerVNC.
2. Ouvrez une nouvelle fenêtre de terminal et entrez un des énoncés suivants :
module load StdEnv/2016 abaqus/6.14.1 ou module load StdEnv/2016 abaqus/2020 ou module load StdEnv/2020 abaqus/2021
3. Lancez l'application avec
abaqus cae
Pour qu'Abaqus puisse démarrer en mode graphique, il faut au moins une licence CAE libre (non utilisée). La licence SHARCNET comporte 2 licences libres et 2 licences réservées. Si les 4 sont utilisées selon
[gra-vdi3:~] abaqus licensing lmstat -c $ABAQUSLM_LICENSE_FILE -a | grep "Users of cae" Users of cae: (Total of 4 licenses issued; Total of 4 licenses in use)
Les messages d'erreur suivants seront affichés quand vous tenterez de lancer Abaqus cae :
[gra-vdi3:~] abaqus cae ABAQUSLM_LICENSE_FILE=27050@license3.sharcnet.ca /opt/sharcnet/abaqus/2020/Commands/abaqus cae No socket connection to license server manager. Feature: cae License path: 27050@license3.sharcnet.ca: FLEXnet Licensing error:-7,96 For further information, refer to the FLEXnet Licensing documentation, or contact your local Abaqus representative. Number of requested licenses: 1 Number of total licenses: 4 Number of licenses in use: 2 Number of available licenses: 2 Abaqus Error: Abaqus/CAE Kernel exited with an error.
Utilisation sur un site spécifique
Licence SHARCNET
SHARCNET fournit une licence petite mais gratuite composée de 2 jetons cae et de 35 jetons d'exécution avec des limites d'utilisation imposées à 10 jetons/utilisateur et 15 jetons/groupe. Pour les groupes qui ont acheté des jetons dédiés, les limites d'utilisation des jetons gratuits sont ajoutées à leur réservation. Les jetons gratuits sont disponibles selon le principe du premier arrivé, premier servi et sont principalement destinés aux tests et à une utilisation légère avant de décider d'acheter ou non des jetons dédiés. Les coûts des jetons dédiés (en 2021) étaient d'environ 110$CA par jeton de calcul et de 400$CA par jeton pour l'interface graphique : soumettez une demande d'assistance pour demander un devis officiel. La licence peut être utilisée par toute personne disposant d'un compte avec l'Alliance, mais uniquement sur le matériel SHARCNET. Les groupes qui achètent des jetons dédiés pour exécution sur le serveur de licences SHARCNET ne peuvent également les utiliser que sur le matériel SHARCNET, y compris gra-vdi (pour exécuter Abaqus en mode graphique complet) et les grappes Graham ou Dusky (pour soumettre des tâches de calcul par lots à la file d'attente). Avant de pouvoir utiliser la licence, vous devez contacter le soutien technique pour demander l'accès. Dans votre courriel, 1) mentionnez qu'il est destiné à être utilisé sur les systèmes SHARCNET et 2) incluez un copier/coller de la déclaration de Contrat de licence suivante avec votre nom complet et votre nom d'utilisateur saisis aux emplacements indiqués. Veuillez noter que chaque utilisateur doit le faire, cela ne peut pas être fait une seule fois pour un groupe ; cela inclut les chercheuses principales et les chercheurs principaux qui ont acheté leurs propres jetons dédiés.
Entente
---------------------------------------------------------------------------------- Subject: Abaqus SHARCNET Academic License User Agreement This email is to confirm that i "_____________" with username "___________" will only use “SIMULIA Academic Software” with tokens from the SHARCNET license server for the following purposes: 1) on SHARCNET hardware where the software is already installed 2) in affiliation with a Canadian degree-granting academic institution 3) for education, institutional or instruction purposes and not for any commercial or contract-related purposes where results are not publishable 4) for experimental, theoretical and/or digital research work, undertaken primarily to acquire new knowledge of the underlying foundations of phenomena and observable facts, up to the point of proof-of-concept in a laboratory -----------------------------------------------------------------------------------
Configurer le fichier de licence
Configurez votre fichier de licence comme suit (pour utilisation uniquement sur les systèmes SHARCNET Graham, gra-vdi et Dusky).
[gra-login1:~] cat ~/.licenses/abaqus.lic
prepend_path("LM_LICENSE_FILE","27050@license3.sharcnet.ca")
prepend_path("ABAQUSLM_LICENSE_FILE","27050@license3.sharcnet.ca")
Si vos tâches se terminent anormalement et que le fichier de sortie de l'ordonnanceur contient le message d'erreur *** ABAQUS/eliT_CheckLicense rank 0 terminated by signal 11 (Segmentation fault), vérifiez si votre fichier abaqus.lic contient ABAQUSLM_LICENSE_FILE pour Abaqus/2020.
Si le fichier de sortie contient License server machine is down or not responding etc., vérifiez si le fichier abaqus.lic contient LM_LICENSE_FILE pour Abaqus/6.14.1, comme montré. Puisque le fichier abaqus.lic montré contient les deux énoncés, vous ne devriez pas avoir ce problème.
Interroger le serveur de licences
Connectez-vous à Graham, chargez Abaqus et exécutez une des commandes suivantesnbsp;:
ssh graham.alliancecan.ca
module load StdEnv/2020
module load abaqus
I) Vérifiez s'il y a des tâches lancées et des tâches dans la queue pour le serveur de licence SHARCNET.
abaqus licensing lmstat -c $LM_LICENSE_FILE -a | egrep "Users|start|queued"
II) Vérifiez s'il y a des tâches lancées et des tâches dans la queue pour le serveur de licence SHARCNET et s'il indique des réservations de produits par groupe d'acquisition.
abaqus licensing lmstat -c $LM_LICENSE_FILE -a | egrep "Users|start|queued|RESERVATION"
III) Vérifiez si le serveur de licences SHARCNET montre une disponibilité pour le produit cae standard et explicite.
abaqus licensing lmstat -c $LM_LICENSE_FILE -a | grep "Users of" | egrep "cae|standard|explicit"
When the output of query I) above indicates that a job for a particular username is queued this means the job has entered the "R"unning state from the perspective of squeue -j jobid or sacct -j jobid and is therefore idle on a compute node waiting for a license. This will have the same impact on your account priority as if the job were performing computations and consuming CPU time. Eventually when sufficient licenses come available the queued job will start.
Example
The following shows the situation where a user submitted two 6-core jobs (each requiring 12 tokens) in quick succession. The scheduler then started each job on a different node in the order they were submitted. Since the user had 10 Abaqus compute tokens, the first job (27527287) was able to acquire exactly enough (10) tokens for the solver to begin running. The second job (27527297) not having access to any more tokens entered an idle "queued" state (as can be seen from the lmstat output) until the first job completed, wasting the available resources and depreciating the user's fair share level in the process ...
[roberpj@gra-login1:~] sq
JOBID USER ACCOUNT NAME ST TIME_LEFT NODES CPUS TRES_PER_N MIN_MEM NODELIST (REASON)
27530366 roberpj cc-debug_cpu scriptsp2.txt R 9:56:13 1 6 N/A 8G gra107 (None)
27530407 roberpj cc-debug_cpu scriptsp2.txt R 9:59:37 1 6 N/A 8G gra292 (None)
[roberpj@gra-login1:~] abaqus licensing lmstat -c $LM_LICENSE_FILE -a | egrep "Users|start|queued" Users of abaqus: (Total of 78 licenses issued; Total of 53 licenses in use) roberpj gra107 /dev/tty (v62.6) (license3.sharcnet.ca/27050 1042), start Mon 11/25 17:15, 10 licenses roberpj gra292 /dev/tty (v62.6) (license3.sharcnet.ca/27050 125) queued for 10 licenses
To avoid license shortage problems when submitting multiple jobs when working with expensive Abaqus tokens either use a job dependency, job array or at the very least set up a slurm email notification to know when your job completes before manually submitting another one.
Indiquer les ressources pour la tâche
Pour garantir une utilisation optimale de vos jetons Abaqus et de nos ressources, il est important de bien spécifier la mémoire et le ncpus requis dans votre script Slurm. Les valeurs peuvent être obtenues en soumettant quelques courtes tâches de test à la file d'attente, puis en vérifiant leur utilisation. Pour les tâches terminées, utilisez seff JobNumber pour afficher la mémoire utilisée totale et l'efficacité de la mémoire. Si l'efficacité de la mémoire est inférieure à environ 90%, diminuez la valeur du paramètre #SBATCH --mem= dans votre script Slurm. Notez que la commande seff JobNumber affiche également le total du CPU (temps) utilisé et l'efficacité du processeur. Si l'efficacité du processeur est inférieure à environ 90%, effectuez des tests de mise à l'échelle pour déterminer le nombre optimal de processeurs pour des performances optimales, puis mettez à jour la valeur de #SBATCH --cpus-per-task= dans votre script Slurm. Pour les tâches en cours d'exécution, utilisez la commande srun --jobid=29821580 --pty top -d 5 -u $USER pour surveiller le %CPU, le %MEM et le RES pour chaque processus parent Abaqus sur le nœud de calcul. Les colonnes %CPU et %MEM affichent le pourcentage d'utilisation par rapport au total disponible sur le nœud tandis que la colonne RES affiche la taille de la mémoire résidente par processus (dans un format facilement lisible pour les valeurs supérieures à 1 Go). De plus amples informations sur la manière de surveiller les tâches sont disponibles sur notre wiki de documentation
Correspondance cœur-jeton
TOKENS 5 6 7 8 10 12 14 16 19 21 25 28 34 38 CORES 1 2 3 4 6 8 12 16 24 32 48 64 96 128
où TOKENS = floor[5 X CORES^0.422]
Chaque GPU nécessite un jeton additionnel.
Licence Western
La licence de site Western ne peut être utilisée que par les chercheuses et chercheurs de Western sur le matériel situé sur le campus de Western. Présentement, la grappe Dusky est la seule qui satisfait ces conditions. Graham et gra-vdi sont exclus car ils sont situés sur le campus de Waterloo. Contactez l'administrateur du serveur de licences Western Abaqus <jmilner@robarts.ca> pour vous renseigner sur l'utilisation de la licence Western. Vous devrez fournir votre nom d'utilisateur et éventuellement prendre des dispositions pour acheter des jetons. Si l'accès vous est accordé, vous pouvez procéder à la configuration de votre fichier abaqus.lic pour qu'il pointe vers le serveur de licences Western comme suit :
Configurer le fichier de licences
Configurez votre fichier de licence comme suit (pour utilisation uniquement sur Dusky).
[dus241:~] cat .licenses/abaqus.lic
prepend_path("LM_LICENSE_FILE","27000@license4.sharcnet.ca")
prepend_path("ABAQUSLM_LICENSE_FILE","27000@license4.sharcnet.ca")
Par la suite, soumettez votre tâche tel que décrit à la section Soumettre une tâche sur une grappe ci-dessus. Si un problème survient, écrivez au soutien technique en indiquant que vous utilisez la licence du site Western sur Dusky. Ajoutez le numéro de la tâche qui pose problème et copiez le ou les messages d'erreur s'il y a lieu.
Documentation en ligne
Vous pouvez consulter la documentation pour la plus récente version sur gra-vdi comme suit :
Préparation de votre compte
- Connectez-vous à gra-vdi.com avec TigerVNC.
- Sur gra-vdi, ouvrez une fenêtre de terminal et entrez
firefox(appuyez sur Entrée). - Dans la barre d'adresse, entrez
about:config(appuyez sur Entrée) -> cliquez sur le bouton I accept the risk. - Dans la barre de recherche, entrez
uniqueet double-cliquez surprivacy.file_unique_originpour changer true' en false.
Afficher la documentation
- Connectez-vous à gra-vdi.com avec TigerVNC.
- Sur gra-vdi, ouvrez une fenêtre de terminal et entrez
firefox(appuyez sur Entrée). - Dans la barre de recherche, copiez-collez un des énoncés suivants :
file:///opt/sharcnet/abaqus/2020/doc/English/DSSIMULIA_Established.htm, oufile:///opt/sharcnet/abaqus/2021/doc/English/DSSIMULIA_Established.htm - Cliquez sur un sujet, par exemple Abaqus -> Analysis -> Analysis Techniques -> Analysis Continuation Techniques.