This page is a translated version of the page Abaqus and the translation is 70% complete.

Outdated translations are marked like this.

Abaqus FEA est un progiciel commercial pour l'analyse d'éléments finis et l'ingénierie assistée par ordinateur.

Licence

Abaqus software modules are available on the Alliance clusters, however you must provide your own license. There are two types of license servers each with different setup procedures described below.

Serveurs FLEXnet

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 la ligne ci-dessous. 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. Si vous voulez utiliser la version 6.14.1, remplacez ABAQUSLM_LICENSE_FILE par LM_LICENSE_FILE.

File : abaqus.lic

prepend_path("ABAQUSLM_LICENSE_FILE","port@server")

[l2 (login node):~/.licenses] cat abaqus.lic
prepend_path("ABAQUSLM_LICENSE_FILE","LMGRD-PORT-NUMBER@FLEXnet-SERVER-HOSTNAME")

rm -f testsp1* testsp2* /cvmfs/soft.computecanada.ca/gentoo/2023/x86-64-v3/usr/bin/unshare \

  --fork --pid --mount-proc --user --map-user $USER \
  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

}}

Serveurs DSLS

Comme c'était le cas avec les modules déjà installés, abaqus/2026 est configuré pour fonctionner avec le serveur de licence Simulia FLEXnet par défaut, tout comme le serveur de licence gratuit de SHARCNET. Pour utiliser un serveur de licence DSLS de votre établissement, vous devez créer les fichiers texte abaqus_v6.env et DSLicSrv.txt dans le répertoire utilisé pour soumettre votre simulation (voir le code ci-dessous). Ils seront lus automatiquement au lancement d'Abaqus et la reconfiguration se fera en conséquence.

[l2 (login node):~ ] cat abaqus_v6.env
license_server_type=DSLS
dsls_license_config="/home/<username>/DSLicSrv.txt"

 [l2 (login node):~ ] cat DSLicSrv.txt
 DSLS-SERVER-HOSTNAME:LICENSING-CLIENT-PORT-NUMBER

[l2 (login node):~/mysimdir] cat abaqus_v6.env

license_server_type=DSLS
dsls_license_config="DSLicSrv.txt"

[l2 (login node):~/mysimdir] DSLicSrv.txt

YOUR-SERVER-HOSTNAME:PORT-NUMBER

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.

If your license server was never set up for use on an Alliance cluster, some additional configuration changes by the Alliance system administrator and your local system administrator will need to be done. Such changes are necessary to ensure the required TCP ports of your Abaqus server are reachable from all cluster compute nodes. For help, please write to technical support and be sure to include the following:

flexlm port number & static vendor port number (FLEXnet server),
administrative port number & licensing client port number (DSLS server),
fully qualified domain name or IPV4 address of your new Abaqus server.

You will be sent a list of cluster IP addresses (known as NAT nodes) so that your administrator can open the local server firewall to allow connections from the cluster on both ports. Please note that a special license agreement must generally be negotiated and signed by both SIMULIA and your institution before a campus license may be legally used on Alliance hardware located remotely at another institution.

License queuing

The default setup for the license server is to queue jobs started on the cluster by Slurm if not enough tokens are available. There are two options to alter this behaviour ie) so jobs don't sit idle on a cluster compute node waiting for a license indefinitely wasting valuable resources. The first option is to terminate a job immediately if not enough licenses are available, therefore never entering a queue. To specify this setting, create a text file named abaqus_v6.env in either your /home OR working (submit) directory containing the line: lmlicensequeuing=OFF. The second option is to specify a finite wait time where the job can enter into a queued state on the license server such as 1 minute by adding the line: lmhanglimit=1. If within 1 minute sufficient licenses do not come available then the job will be dequeud by the license server and in turn be terminated by Slurm. For each option, messages will be printed at the bottom of the Slurm output file as shown in the Example below.

Compatibilité des versions

Nouveau module

Un nouveau module pour abaqus/2026 est installé dans l'environnement par défaut StdEnv/2023. La nouvelle version résout la source de l'erreur *** buffer overflow detected *** qui survenait sur toutes les récentes grappes avec abaqus/2021. Les scripts Slurm présentés dans cette page ont été adaptés pour fonctionner avec abaqus/2026 et abaqus/2021 lorsque possible; vous devez donc modifier tous les scripts Slurm que vous utilisez. Le module abaqus/2026 contient la version initiale Abaqus 2026 Golden. Un autre module nommé abaqus/2026.2606 contient les mises à niveau Abaqus 2026 FP.CFA.2606 et sera installé prochainement.

Soumettre des tâches en lots

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 sur 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

script pour le répertoire /projectscript de redémarrage pour le répertoire /projectscript pour répertoire temporairescript de redémarrage pour le répertoire temporaire

File : "scriptsp1.txt"

#!/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=granite   # Uncomment to specify a node type
##SBATCH --gpus-per-node=h100:1 # Uncomment to specify [type:]number

module load abaqus/2026         # Latest version
#module load StdEnv/2020        # Legacy version
#module load abaqus/2021        # Discontinue 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*

if [[ $EBVERSIONABAQUS -eq 2021 ]]; then
   /cvmfs/soft.computecanada.ca/gentoo/2023/x86-64-v3/usr/bin/unshare \
   --fork --pid --mount-proc --user --map-user $USER \
   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
elif [[ $EBVERSIONABAQUS -ge 2026 ]]; then
   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
fi

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

File : "scriptsp2.txt"

#!/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=granite   # Uncomment to specify a node type
##SBATCH --gpus-per-node=h100:1 # Uncomment to specify [type:]number

module load abaqus/2026         # Latest version
#module load StdEnv/2020        # Legacy version
#module load abaqus/2021        # Discontinue 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 testsp2* testsp1.lck

if [[ $EBVERSIONABAQUS -eq 2021 ]]; then
   /cvmfs/soft.computecanada.ca/gentoo/2023/x86-64-v3/usr/bin/unshare \
   --fork --pid --mount-proc --user --map-user $USER \
   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
elif [[ $EBVERSIONABAQUS -ge 2026 ]]; then
   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
fi

Le fichier en entrée pour le redémarrage doit contenir

*HEADING
*RESTART, READ

{{File

 |name="scriptst1.txt"
 |lang="sh"
 |contents=

File : "scriptst1.txt"

#!/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=granite   # Uncomment to specify a node type
##SBATCH --gpus-per-node=h100:1 # Uncomment to specify [type:]number


module load abaqus/2026         # Latest version
#module load StdEnv/2020        # Legacy version
#module load abaqus/2021        # Discontinue use

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=$!

if [[ $EBVERSIONABAQUS -eq 2021 ]]; then
   /cvmfs/soft.computecanada.ca/gentoo/2023/x86-64-v3/usr/bin/unshare \
   --fork --pid --mount-proc --user --map-user $USER \
   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
elif [[ $EBVERSIONABAQUS -ge 2026 ]]; then
   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
fi

{ 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

File : "scriptst2.txt"

#!/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=granite   # Uncomment to specify a node type
##SBATCH --gpus-per-node=h100:1 # Uncomment to specify [type:]number

module load abaqus/2026         # Latest version
#module load StdEnv/2020        # Legacy version
#module load abaqus/2021        # Discontinue use

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=$!

if [[ $EBVERSIONABAQUS -eq 2021 ]]; then
   /cvmfs/soft.computecanada.ca/gentoo/2023/x86-64-v3/usr/bin/unshare \
   --fork --pid --mount-proc --user --map-user $USER \
   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
elif [[ $EBVERSIONABAQUS -ge 2026 ]]; then
   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
fi

{ 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. Avec ce script, vous pouvez utiliser uniquement abaqus/2026 et versions plus récentes.

File : "scriptsp1-mpi.txt"

!/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 abaqus/2026         # Latest 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

script pour le répertoire /projectscript de redémarrage pour le répertoire /projectscript pour le répertoire temporairescript de redémarrage pour le répertoire temporaire

File : "scriptep1.txt"

#!/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 abaqus/2026         # Latest version
#module load StdEnv/2020        # Legacy version
#module load abaqus/2021        # Discontinue 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 testep1* testep2*

if [[ $EBVERSIONABAQUS -eq 2021 ]]; then
   /cvmfs/soft.computecanada.ca/gentoo/2023/x86-64-v3/usr/bin/unshare \
   --fork --pid --mount-proc --user --map-user $USER \
   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"
elif [[ $EBVERSIONABAQUS -ge 2026 ]]; then
   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"
fi

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

File : "scriptep2.txt"

#!/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 abaqus/2026         # Latest version
#module load StdEnv/2020        # Legacy version
#module load abaqus/2021        # Discontinue 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 testep2* testep1.lck
for f in testep1*; do [[ -f ${f} ]] && cp -a "$f" "testep2${f#testep1}"; done

if [[ $EBVERSIONABAQUS -eq 2021 ]]; then
   /cvmfs/soft.computecanada.ca/gentoo/2023/x86-64-v3/usr/bin/unshare \
   --fork --pid --mount-proc --user --map-user $USER \
   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"
elif [[ $EBVERSIONABAQUS -ge 2026 ]]; then
   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"
fi

Le fichier en entrée ne requiert aucune modification pour le redémarrage de l'analyse.

File : "scriptet1.txt"

#!/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 abaqus/2026         # Latest version
#module load StdEnv/2020        # Legacy version
#module load abaqus/2021        # Discontinue use

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=$!

if [[ $EBVERSIONABAQUS -eq 2021 ]]; then
   /cvmfs/soft.computecanada.ca/gentoo/2023/x86-64-v3/usr/bin/unshare \
   --fork --pid --mount-proc --user --map-user $USER \
   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"
elif [[ $EBVERSIONABAQUS -ge 2026 ]]; then
   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"
fi

{ 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

File : "scriptet2.txt"

#!/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 abaqus/2026         # Latest version
#module load StdEnv/2020        # Legacy version
#module load abaqus/2021        # Discontinue use

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=$!

if [[ $EBVERSIONABAQUS -eq 2021 ]]; then
   /cvmfs/soft.computecanada.ca/gentoo/2023/x86-64-v3/usr/bin/unshare \
   --fork --pid --mount-proc --user --map-user $USER \
   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"
elif [[ $EBVERSIONABAQUS -ge 2026 ]]; then
   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"
fi

{ 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

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. Avec ce script, vous pouvez utiliser uniquement abaqus/2026 et versions plus récentes.

File : "scriptep1-mpi.txt"

!/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 abaqus/2026        # Latest version

unset SLURM_GTIDS
export MPI_IC_ORDER='tcp'
#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

Une estimation de la mémoire totale pour un processus avec fils sur un nœud unique peut aussi ê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. 1) Connectez-vous d'abord à une grappe avec SSH et obtenez une allocation sur un nœud de calcul (comme gra100) et démarrez votre simulation avec :

[name@server ~]$ module load StdEnv/2020
[name@server ~]$ module load abaqus/2021
[name@server ~]$ unset SLURM_GTIDS

2) Ensuite, via SSH, connectez-vous au nœud de calcul et lancez top.

[name@server ~]$ ssh c50
[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'assurer 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 Slurm requise pour les scripts Slurm multinœuds, les estimations de mémoire (par processus de calcul) nécessaires pour minimiser les entrées/sorties sont fournies dans le fichier de sortie .dat pour les tâches terminées. Si mp_host_split n'est pas spécifié (ou est égal à 1), le nombre total de processus de calcul sera égal au nombre de nœuds. La valeur de mem-per-cpu peut alors être estimée en multipliant l'estimation de mémoire la plus élevée par le nombre de nœuds, puis en divisant par le nombre de tâches (ntasks). En revanche, si une valeur pour mp_host_split est spécifiée (supérieure à 1), la valeur de mem-per-cpu peut être estimée en multipliant l'estimation de mémoire la plus élevée par le nombre de nœuds, puis par la valeur de mp_host_split, et en divisant le résultat par le nombre de tâches. Notez que mp_host_split doit être inférieur ou égal au nombre de cœurs par nœud attribués par Slurm lors de l'exécution, autrement Abaqus fermera. Ce scénario peut être contrôlé en supprimant le commentaire pour la ligne qui permet de spécifier une valeur pour tasks-per-node. Le message suivant, présent dans chaque fichier de sortie, est mentionné ici à titre de référence :

[traduction libre] 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.

Graphical use

Nous recommandons d'utiliser Open OnDemand ou Jupyter pour travailler avec des applications graphiques.

OnDemand

1. Lancez une session OnDemand sur votre bureau en cliquant sur le lien approprié.
NIBI : https://ondemand.sharcnet.ca
TRILLIUM : https://ondemand.scinet.utoronto.ca

2. Ouvrez une nouvelle fenêtre de terminal et chargez

module load abaqus/2026

3. Lancez l'application en mode graphique avec l'option cae. Si vous êtes sur un nœud sans GPU ou sur un nœud avec GPU où VirtualGL n'est pas pris en charge, ajoutez l'option mesa.

abaqus cae -mesa

4. Si vous avez besoin d'une meilleure performance graphique et êtes sur un nœud avec GPU où VirtualGL est pris en charge, lancez Abaqus sans l'option mesa. Dans Nibi Desktop, sélectionnez h100 (80GB) dans le menu déroulant.

abaqus cae

5. Pour lancer Abaqus en mode graphique, il faut au moins une licence de calcul non utilisée, selon

$ abaqus licensing lmstat -c $ABAQUSLM_LICENSE_FILE -a | grep "Users of cae"
Users of cae:  (Total of 4 licenses issued;  Total of 3 licenses in use)

JupyterLab

1. Sur votre bureau, lancez une session JupyterHub en cliquant sur une URL ci-dessous.

FIR: https://jupyterhub.fir.alliancecan.ca
NARVAL:  https://portail.narval.calculquebec.ca/
RORQUAL: https://jupyterhub.rorqual.alliancecan.ca

2. Sélectionnez un module COMSOL (par exemple comsol/6) dans la section Available Module de gauche.
3. Pour le module sélectionné, cliquez sur Load pour faire afficher l'icône Comsol (VNC) sur le bureau.
4. Cliquez sur l'icône et COMSOL devrait automatiquement démarrer sur un bureau Jupyter à distance.

VncViewer

Cette approche est obsolète. Veuillez utiliser un bureau OnDemand ou JupyterLab comme décrit ci-dessus.

1. Avec un client VncViewer, connectez-vous à un nœud de calcul ou de connexion sans GPU, comme décrit dans TigerVNC.
2. Ouvrez une nouvelle fenêtre de terminal et entrez

 module load abaqus/2026

3. Lancez l'application avec

abaqus cae -mesa

Utilisation spécifique au site

Licence SHARCNET

La licence SHARCNET a été renouvelée jusqu'au 17 janvier 2026. Elle offre une licence gratuite limitée comprenant 2 jetons de calcul et 35 jetons d'exécution, avec des limites d'utilisation de 10 jetons par utilisateur et 15 jetons par groupe. Pour les groupes ayant acquis des jetons dédiés, les limites d'utilisation des jetons gratuits sont ajoutées à leur réservation. Les jetons gratuits sont attribués 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. Le coût des jetons dédiés (en 2021) était d'environ 110 $ CA par jeton de calcul et 400 $ CA par jeton d'interface graphique : écrivez au soutien technique pour obtenir un devis officiel. La licence peut être utilisée avec un compte de l'Alliance, mais uniquement sur le matériel SHARCNET. Les groupes qui achètent des jetons dédiés pour le serveur de licences SHARCNET ne peuvent les utiliser que sur le matériel SHARCNET, notamment le système SHARCNET OOD (pour le mode graphique) ou les grappes Nibi/Dusky (pour soumettre des tâches de calcul par lots à la file d'attente). Avant d'utiliser la licence, vous devez contacter le soutien technique et demander l'accès. Dans votre courriel, veuillez 1) préciser que la demande est destinée à une utilisation sur les systèmes SHARCNET et 2) copier coller l'accord de licence suivant, en indiquant vos nom et prénom ainsi que votre nom d'utilisateur aux emplacements prévus. Veuillez noter que chaque utilisateur doit effectuer cette démarche; elle ne peut être effectuée une seule fois pour un groupe, y compris pour les chercheuses principales et chercheurs principaux ayant 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:

<div class="mw-translate-fuzzy">
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 (uniquement sur les systèmes SHARCNET comme les grappes Nibi et Dusky ou sur le système de bureau OOD de SHARCNET). Pour utiliser la licence SHARCNET gratuite, vous devez mettre à jour votre fichier abaqus.lic comme suit, puisque le serveur license3.sharcnet.ca est définitivement fermé.

[l2 (nibi login node):~] cat ~/.licenses/abaqus.lic
prepend_path("ABAQUSLM_LICENSE_FILE","27050@license1.computecanada.ca")

Si votre tâche se termine anormalement avec 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/202X. Si le message d'erreur est License server machine is down or not responding etc. et que vous utilisez Abaqus/6.14.1, remplacez ABAQUSLM_LICENSE_FILE par LM_LICENSE_FILE.

Interroger le serveur de licences

Connectez-vous à Nibi, chargez Abaqus et exécutez une des commandes suivante&snbsp;:

ssh nibi.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 $ABAQUSLM_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 $ABAQUSLM_LICENSE_FILE -a | egrep "Users|start|queued|RESERVATION"

III) Vérifiez si le serveur de licences SHARCNET montre une disponibilité explicite pour le produit standard pour le calcul.

abaqus licensing lmstat -c $ABAQUSLM_LICENSE_FILE -a | grep "Users of" | egrep "cae|standard|explicit"

Lorsque le résultat de la requête I) ci-dessus indique qu'une tâche associée à un nom d'utilisateur donné est en file d'attente, cela signifie que la tâche est passée à l'état R (running) pour squeue -j jobid ou sacct -j jobid et qu'elle est donc inactive sur un nœud de calcul, en attente d'une licence. Cela aura le même impact sur la priorité de votre compte que si la tâche effectuait des calculs et consommait du temps CPU. La tâche en file d'attente démarrera dès que suffisamment de licences seront disponibles.

Exemple

L'exemple suivant illustre la situation où un utilisateur soumet successivement deux tâches pour 6 cœurs, nécessitant chacune 12 jetons. L'ordonnanceur a ensuite lancé chaque tâche sur un nœud différent, dans l'ordre de leur soumission. L'utilisateur disposant de 10 jetons Abaqus, la première tâche (27527287) a pu obtenir exactement les 10 jetons nécessaires au démarrage du solveur. La seconde tâche (27527297), n'ayant plus accès à des jetons, est restée en attente (comme le montre la sortie de lmstat) jusqu'à la fin de la première, gaspillant ainsi les ressources disponibles et réduisant la juste part de l'utilisateur.

[l2 (nibi login node):~] 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     c107  (None) 
        27530407  roberpj         cc-debug_cpu  scriptsp2.txt   R    9:59:37     1    6        N/A      8G     c292  (None)

[l2 (nibi login node):~] abaqus licensing lmstat -c $ABAQUSLM_LICENSE_FILE -a | egrep "Users|start|queued"
Users of abaqus:  (Total of 78 licenses issued;  Total of 53 licenses in use)
   roberpj c107 /dev/tty (v62.6) (license3.sharcnet.ca/27050 1042), start Mon 11/25 17:15, 10 licenses
   roberpj c292 /dev/tty (v62.6) (license3.sharcnet.ca/27050 125) queued for 10 licenses

Pour éviter les problèmes de pénurie de licences lors de la soumission de plusieurs tâches avec des jetons Abaqus coûteux, utilisez soit une dépendance, un vecteur, soit au moins configurez une notification par courriel Slurm pour savoir quand votre tâche est terminée avant d'en soumettre une autre manuellement.

Option 1)

Disable non-interactive (analysis) jobs from starting on a cluster compute node after being submitted to the queue and then becoming idle (when not enough tokens are unavailable the default bahaviour) create a text file in your submit directory (before submitting the job) with the following one line contents and the job will instead terminate immediately.

[l2 (nibi login node):~/submitdirectory] cat abaqus_v6.env
lmlicensequeuing=OFF

When a job immediately terminates (without entering a QUEUED state to wait for a license) the end of the corresponding Slurm output file will contain messages such as

Abaqus 2026   
Checkout exceeds MAX specified in options file.
FlexNet Licensing error:-87,147
Number of requested licenses: 14
Number of total licenses:     78
Number of licenses in use:    14
Number of available licenses: 64
This may be due to insufficient licenses.
ValueError: not enough values to unpack (expected 2, got 1)
During handling of the above exception, another exception occurred:
Exception: DriverLM: can't parse host/port from umbrella
Abaqus Error: Error checking out Abaqus license.
Abaqus/Analysis exited with errors

Option 2)

Specify a setting in minutes so that a started job will enter a QUEUED state to wait for a license before being automatically DEQUEUED and terminating if a license does not become available in time.

[l2 (nibi login node):~/submitdirectory] cat abaqus_v6.env
 lmhanglimit=1

When a job terminates this way, after being queued and no license comes available in the specified time according to the lmhanlimit value (1minute in this example) the messages at the end of the Slurm output file will instead appear as

Abaqus 2026
"standard" license request queued for the License Server on license1.computecanada.ca. 
Total time in queue: 0 seconds.
"standard" license request queued for the License Server on license1.computecanada.ca. 
Total time in queue: 30 seconds.
"standard" license request queued for the License Server on license1.computecanada.ca. 
Total time in queue: 60 seconds.
Time limit of in queue has been exceeded. Exiting.
This may be due to insufficient licenses.
ValueError: not enough values to unpack (expected 2, got 1)
During handling of the above exception, another exception occurred:
Exception: DriverLM: can't parse host/port from umbrella
Abaqus Error: Error checking out Abaqus license.
Abaqus/Analysis exited with errors

Specify job resources

To ensure optimal usage of both your Abaqus tokens and our resources, it's important to carefully specify the required memory and ncpus in your Slurm script. The values can be determined by submitting a few short test jobs to the queue then checking their utilization. For completed jobs use seff JobNumber to show the total Memory Utilized and Memory Efficiency. If the Memory Efficiency is less than ~90%, decrease the value of the #SBATCH --mem= setting in your Slurm script accordingly. Notice that the seff JobNumber command also shows the total CPU (time) Utilized and CPU Efficiency. If the CPU Efficiency is less than ~90%, perform scaling tests to determine the optimal number of CPUs for optimal performance and then update the value of #SBATCH --cpus-per-task= in your Slurm script. For running jobs, use the srun --overlap --jobid=29821580 --pty top -d 5 -u $USER command to watch the %CPU, %MEM and RES for each Abaqus parent process on the compute node. The %CPU and %MEM columns display the percent usage relative to the total available on the node while the RES column shows the per process resident memory size (in human readable format for values over 1GB). Further information regarding how to monitor jobs is available on our documentation wiki

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 de Western

[[ Le fichier abaqus.lic ci-dessous ne fonctionne plus, car la machine license4 a été mise hors service définitivement. Par conséquent, toutes les demandes d'accès à une licence Abaqus sur la grappe Dusky à partir du serveur de licences Abaqus Western/Robarts échoueront. Un serveur de remplacement pour license4 est en préparation. Dès qu'il sera en fonction, le fichier abaqus.lic sera mis à jour avec le nouveau nom du serveur et ce message d'avertissement rouge sera supprimé. En attendant, la licence SHARCNET peut être utilisée en suivant la procédure de demande d'accès ci-dessus. ]]

La licence Western est réservée aux chercheurs et chercheuses de Western et ne peut être utilisée que sur du matériel situé sur le campus. Actuellement, seulement la grappe Dusky remplit cette condition. Les systèmes Nibi et SHARCNET OOD sont exclus, car ils se trouvent sur le campus de Waterloo. Pour toute question concernant l'utilisation de la licence Abaqus de Western, veuillez contacter l'administrateur du serveur de licences Abaqus de Western à l'adresse <jmilner@robarts.ca>. Vous devrez fournir votre nom d'utilisateur et éventuellement prévoir l'achat de jetons. Si votre demande d'accès est acceptée, vous pourrez configurer votre fichier abaqus.lic pour qu'il pointe vers le serveur de licences de Western.

Configurer le fichier de licences

[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.

Abaqus

Contents

Licence

Serveurs FLEXnet

Serveurs DSLS

License queuing

Compatibilité des versions

Nouveau module

Soumettre des tâches en lots

Analyse standard

Scripts pour un nœud simple

Script pour nœuds multiples

Analyse explicite

Scripts pour un nœud simple

Script pour nœuds multiples

Estimer le besoin en termes de mémoire

Processus simple

Processus multiples

Graphical use

OnDemand

JupyterLab

VncViewer

Utilisation spécifique au site

Licence SHARCNET

Entente

Configurer le fichier de licence

Interroger le serveur de licences

Exemple

Specify job resources

Correspondance cœur-jeton

Licence de Western

Configurer le fichier de licences

Navigation menu

Abaqus

Licence

Serveurs FLEXnet

Serveurs DSLS

License queuing

Compatibilité des versions

Nouveau module

Soumettre des tâches en lots

Analyse standard

Scripts pour un nœud simple

Script pour nœuds multiples

Analyse explicite

Scripts pour un nœud simple

Script pour nœuds multiples

Estimer le besoin en termes de mémoire

Processus simple

Processus multiples

Graphical use

OnDemand

JupyterLab

VncViewer

Utilisation spécifique au site

Licence SHARCNET

Entente

Configurer le fichier de licence

Interroger le serveur de licences

Exemple

Specify job resources

Correspondance cœur-jeton

Licence de Western

Configurer le fichier de licences

Navigation menu

Search