NAMD

From Alliance Doc
Jump to navigation Jump to search
This site replaces the former Compute Canada documentation site, and is now being managed by the Digital Research Alliance of Canada.

Ce site remplace l'ancien site de documentation de Calcul Canada et est maintenant géré par l'Alliance de recherche numérique du Canada.

This page is a translated version of the page NAMD and the translation is 100% complete.
Other languages:


NAMD est un logiciel de dynamique moléculaire orienté-objet conçu pour la simulation de gros systèmes biomoléculaires. Les simulations sont préparées et analysées dans le logiciel de visualisation VMD.


Installation

Le logiciel est installé par notre équipe technique et est disponible via des modules. Si vous avez besoin d'une version plus récente, que vous devez faire vous-même l'installation ou que vous avez des questions, contactez le soutien technique.

Modules d'environnement

Nous vous recommandons d'utiliser la plus récente version 2.14 installée sur nos grappes.

Les versions 2.13 et 2.12 sont cependant disponibles.

Pour les tâches exécutées sur plusieurs nœuds, utilisez UCX.

Scripts

L'information sur l'ordonnanceur Slurm se trouve à la page Exécuter des tâches.

Tâches séquentielles et tâches multifils

Le script suivant est pour une simulation séquentielle sur un seul cœur. Pour utiliser plus de cœurs, augmentez la valeur de --cpus-per-task, sans dépasser le nombre de cœurs disponible sur le nœud.

File : serial_namd_job.sh

#!/bin/bash
#
#SBATCH --cpus-per-task=1
#SBATCH --mem 2048            # memory in Mb, increase as needed    
#SBATCH -o slurm.%N.%j.out    # STDOUT file
#SBATCH -t 0:05:00            # time (D-HH:MM), increase as needed
#SBATCH --account=def-specifyaccount

module load StdEnv/2020
module load namd-multicore/2.14
namd2 +p$SLURM_CPUS_PER_TASK  +idlepoll apoa1.namd


Tâches parallèles sur CPU

Tâches MPI

NOTE : N'utilisez pas MPI mais plutôt UCX.

Tâches verbs

NOTE: Avec NAMD 2.14, utilisez UCX sur les autres grappes. Les directives ci-dessous s'appliquent uniquement aux versions NAMD 2.13 et 2.12.


Ces directives seront mises à jour une fois cette configuration testée sur les nouvelles grappes. Dans cet exemple, nous utilisons 64 processus sur 2 nœuds, à raison de 32 processus par nœud; les 32 cœurs sont donc pleinement utilisés. Nous supposons que des nœuds entiers sont utilisés et ntasks-per-node devrait être 32 sur Graham. Pour une performance optimale, utilisez des nœuds entiers.

NOTES:

  • Les versions Verbs ne fonctionnent pas sur Cedar en raison de la réseautique qui est différente; utilisez plutôt la version MPI.
  • Les versions verbs ne fonctionnent pas sur Béluga en raison de l'incompatibilité des pilotes du noyau InfiniBand; utilisez plutôt la version UCX.
File : verbs_namd_job.sh

#!/bin/bash
#
#SBATCH --nodes=2
#SBATCH --ntasks-per-node=32
#SBATCH --mem=0            # memory per node, 0 means all memory
#SBATCH -o slurm.%N.%j.out    # STDOUT
#SBATCH -t 0:05:00            # time (D-HH:MM)
#SBATCH --account=def-specifyaccount

NODEFILE=nodefile.dat
slurm_hl2hl.py --format CHARM > $NODEFILE
P=$SLURM_NTASKS

module load namd-verbs/2.12
CHARMRUN=`which charmrun`
NAMD2=`which namd2`
$CHARMRUN ++p $P ++nodelist $NODEFILE  $NAMD2  +idlepoll apoa1.namd


Tâches UCX

L'exemple suivant utilise 80 processus à raison de 40 processus par nœud sur 2 nœuds et utilise ainsi pleinement les 80 cœurs. Le script suppose que des nœuds entiers sont utilisés; ainsi, sur Béluga, ntasks-per-node devrait être 40. Les tâches NAMD qui utilisent des nœuds entiers offrent la meilleure performance.


NOTE : Les versions UCX devraient fonctionner sur toutes les grappes.

File : ucx_namd_job.sh

#!/bin/bash
#
#SBATCH --nodes=2
#SBATCH --ntasks-per-node=40
#SBATCH --mem=0            # memory per node, 0 means all memory
#SBATCH -o slurm.%N.%j.out    # STDOUT
#SBATCH -t 0:05:00            # time (D-HH:MM)
#SBATCH --account=def-specifyaccount

module load StdEnv/2020 namd-ucx/2.14
srun --mpi=pmi2 namd2 apoa1.namd


Tâches OFI

NOTE: Les versions OFI fonctionnent UNIQUEMENT sur Cedar en raison de sa réseautique qui est différente. Des problèmes sont survenus avec OFI et il est préférable d'utiliser UCX.

File : ucx_namd_job.sh

#!/bin/bash
#SBATCH --account=def-specifyaccount
#SBATCH --nodes=2
#SBATCH --ntasks-per-node=32
#SBATCH -t 0:05:00            # time (D-HH:MM)
#SBATCH --mem=0            # memory per node, 0 means all memory
#SBATCH -o slurm.%N.%j.out    # STDOUT

module load StdEnv/2020 namd-ofi/2.14
srun --mpi=pmi2 namd2 stmv.namd


Tâches utilisant 1 GPU

Le prochain exemple utilise huit cœurs CPU et un GPU P100 sur un seul nœud.

File : multicore_gpu_namd_job.sh

#!/bin/bash

#SBATCH --cpus-per-task=8 
#SBATCH --mem=2048            
#SBATCH --time=0:15:00
#SBATCH --gpus-per-node=p100:1
#SBATCH --account=def-specifyaccount

module load StdEnv/2020
module load cuda/11.0
module load namd-multicore/2.14
namd2 +p$SLURM_CPUS_PER_TASK  +idlepoll apoa1.namd



Tâches utilisant plusieurs GPU

Tâches UCX avec GPU

Cet exemple est pour Béluga et suppose que des nœuds entiers sont utilisés, ce qui offre une meilleure performance pour les tâches NAMD. L'exemple utilise 8 processus sur 2 nœuds, chaque processus utilisant 10 fils et 1 GPU. Ceci utilise pleinement les nœuds GPU de Béluga qui ont 40 cœurs et 4 GPU par nœud. Remarquez que 1 cœur par tâche est réservé à un fil de communication; il est donc normal que NAMD ne rapporte que 72 cœurs utilisés.

Pour utiliser ce script sur une autre grappe, voyez les caractéristiques des nœuds disponibles sur la grappe et ajustez les options --cpus-per-task et --gpus-per-node en conséquence.

NOTE : Les versions UCX peuvent être utilisées sur toutes les grappes.

File : ucx_namd_job.sh

#!/bin/bash

#SBATCH --nodes=2
#SBATCH --ntasks-per-node=4
#SBATCH --cpus-per-task=10 # number of threads per task (process)
#SBATCH --gpus-per-node=v100:4
#SBATCH --mem=0            # memory per node, 0 means all memory
#SBATCH --time=0:15:00
#SBATCH --account=def-specifyaccount

module load StdEnv/2020  intel/2020.1.217  cuda/11.0 namd-ucx-smp/2.14
NUM_PES=$(expr $SLURM_CPUS_PER_TASK - 1 )
srun --cpus-per-task=$SLURM_CPUS_PER_TASK --mpi=pmi2 namd2 ++ppn $NUM_PES apoa1.namd


Tâches OFI avec GPU

NOTE: Les versions OFI fonctionnent UNIQUEMENT sur Cedar en raison de sa réseautique qui est différente. Des problèmes sont survenus avec OFI et il est préférable d'utiliser UCX.

File : ucx_namd_job.sh

#!/bin/bash
#SBATCH --account=def-specifyaccount
#SBATCH --ntasks 8            # number of tasks
#SBATCH --nodes=2
#SBATCH --cpus-per-task=6
#SBATCH --gpus-per-node=p100:4
#SBATCH -t 0:05:00            # time (D-HH:MM)
#SBATCH --mem=0            # memory per node, 0 means all memory

module load StdEnv/2020 cuda/11.0 namd-ofi-smp/2.14
NUM_PES=$(expr $SLURM_CPUS_PER_TASK - 1 )
srun --cpus-per-task=$SLURM_CPUS_PER_TASK --mpi=pmi2 namd2 ++ppn $NUM_PES stmv.namd


Tâches verbs avec GPU

NOTE: Avec NAMD 2.14, utilisez les GPU UCX sur toutes les grappes. Les directives ci-dessous s'appliquent à NAMD 2.13 et 2.12.

Cet exemple utilise 64 processus sur 2 nœuds, chaque nœud exécutant 32 processus, ce qui utilise pleinement les 32 cœurs. Chaque nœud utilise 2 GPU, donc la tâche utilise un total de 4 GPU. Le script suppose que des nœuds entiers sont utilisés; sur Graham, ntasks-per-node serait 32. Les tâches NAMD qui utilisent des nœuds entiers offrent la meilleure performance.

NOTE : Les versions verbs ne fonctionnent pas sur Cedar à cause de différences de réseautique.

File : verbsgpu_namd_job.sh

#!/bin/bash
#
#SBATCH --ntasks 64            # number of tasks
#SBATCH --nodes=2
#SBATCH --ntasks-per-node=32
#SBATCH --mem 0            # memory per node, 0 means all memory
#SBATCH --gpus-per-node=p100:2
#SBATCH -o slurm.%N.%j.out    # STDOUT
#SBATCH -t 0:05:00            # time (D-HH:MM)
#SBATCH --account=def-specifyaccount

slurm_hl2hl.py --format CHARM > nodefile.dat
NODEFILE=nodefile.dat
OMP_NUM_THREADS=32
P=$SLURM_NTASKS

module load cuda/8.0.44
module load namd-verbs-smp/2.12
CHARMRUN=`which charmrun`
NAMD2=`which namd2`
$CHARMRUN ++p $P ++ppn $OMP_NUM_THREADS ++nodelist $NODEFILE  $NAMD2  +idlepoll apoa1.namd


Étalonnage (benchmarking)

Vous verrons ici un exemple d'étalonnage. La performance de NAMD varie selon les systèmes simulés, en rapport particulièrement avec la quantité d'atomes. Il serait donc très utile d'effectuer le type d'étalonnage montré ici dans les cas où la simulation d'un système particulier serait de longue durée. Les données ainsi collectées peuvent aussi servir à documenter vos demandes aux concours d'allocation de ressources.

Pour obtenir des résultats pertinents, nous vous suggérons de varier le nombre d'étapes pour que la simulation du système se fasse sur quelques minutes et que la collecte des données de durée se fasse à des intervalles d'au moins quelques secondes. Vous pourriez remarquer des variations dans vos résultats de durée si le temps d'exécution est trop court.

Les données ci-dessous proviennent d'un étalonnage standard apoa1 effectué sur la grappe Graham qui possède des nœuds CPU de 32 cœurs et des nœuds GPU de 32 cœurs et 2 GPU. Pour faire le même exercice avec une autre grappe, vous devrez tenir compte de la structure de ses nœuds.

Dans le premier tableau, nous utilisons NAMD 2.12 chargé du module verbs. L'efficacité est calculée avec (durée avec 1 cœur) / (N * (durée avec N cœurs) ).

# cœurs Durée réelle par étape Efficacité
1 0.8313 100%
2 0.4151 100%
4 0.1945 107%
8 0.0987 105%
16 0.0501 104%
32 0.0257 101%
64 0.0133 98%
128 0.0074 88%
256 0.0036 90%
512 0.0021 77%

Dans ce cas, nous constatons qu'il est acceptable d'utiliser 256 cœurs pour simuler le système. Si vous demandez plus de cœurs qu'il n'en faut, vos tâches seront plus longtemps en attente et votre résultat d'ensemble en serait affecté.

Dans le prochain cas, l'étalonnage est fait avec l'utilisation de GPU. Le module multicœur de NAMD est utilisé pour les simulations pouvant être effectuées avec un (1) nœud alors que le module verbs-smp sert dans les cas de tâches nécessitant plusieurs nœuds.

# cœurs #GPU Durée réelle par étape Notes
4 1 0.0165 1 nœud, multicœur
8 1 0.0088 1 nœud, multicœur
16 1 0.0071 1 nœud, multicœur
32 2 0.0045 1 nœud, multicœur
64 4 0.0058 2 nœuds, verbs-smp
128 8 0.0051 2 nœuds, verbs-smp

Les données du tableau indiquent clairement qu'il est absolument inutile d'utiliser plus d'un nœud puisque la performance décroît avec 2 nœuds ou plus. Avec 1 nœud, il est préférable d'utiliser 1 GPU/16 cœurs puisque l'efficacité est maximale; l'utilisation de 2 GPU/32 cœurs est acceptable si vos résultats doivent être produits rapidement. Puisque les nœuds GPU de Graham l'ordre de priorité est le même pour toutes les tâches 1 GPU/16 cœurs, il n'y a aucun avantage à utiliser 4 ou 8 cœurs.

On peut se demander si la simulation peut ou non utiliser un GPU. Les résultats de l'étalonnage indiquent que l'utilisation d'un nœud GPU (2 GPU/32 cœurs) sur Graham traite la tâche plus rapidement que sur 4 nœuds qui ne sont pas des GPU. Puisque le coût d'un nœud GPU sur Graham est près de deux fois plus que celui d'un nœud qui n'est pas un GPU, il est plus économique d'utiliser les GPU. C'est ce que vous devriez faire tant que c'est possible, mais puisque les nœuds CPU sont en plus grand nombre, vous devriez considérer aussi ne pas utiliser de GPU si le temps d'attente est trop long.

NAMD 3

NAMD 3 est maintenant disponible en mode ALPHA, ce qui pourrait améliorer la performance dans le cas de certaines configurations.

Pour l'utiliser, vous pouvez télécharger le binaire à partir du site web NAMD website et le modifier pour nos systèmes avec, par exemple 

tar xvfz NAMD_3.0alpha11_Linux-x86_64-multicore-CUDA-SingleNode.tar.gz 
cd NAMD_3.0alpha11_Linux-x86_64-multicore-CUDA
setrpaths.sh  --path .

Par la suite, l'exécutable namd3 dans ce répertoire sera lié aux librairies appropriées. Vous pouvez alors soumettre une tâche pour un GPU qui utilise cet exécutable.

Pour obtenir une meilleure performance, nous vous recommandons d'ajouter au fichier de configuration le mot-clé suivant 

CUDASOAintegrate on

Pour plus d'information sur ce paramètre et ses changements, voir cette page.

Références

Message Passing Interface

Retrieved from "https://docs.alliancecan.ca/mediawiki/index.php?title=NAMD/fr&oldid=134895"