GROMACS is an engine to perform molecular dynamics simulations and energy minimization.

• Site web http://www.gromacs.org/
• Versions installées :
  • 5.0.2 avec support OpenMP et thread-MPI
  • 5.0.2 avec support OpenMP et MPI
  • 5.0.2 avec support OpenMP et GPU NVidia ( compilé avec Intel composer 2013)
  • 5.0.4, en simple et double précision, avec MPI ou sans

Voir les manuels d'utilisation sur http://www.gromacs.org/Documentation/Manual

Pour une discussion sur la parallélisation : http://www.gromacs.org/Documentation/Acceleration_and_parallelization

Pour sélectionner la version voulue : utiliser les modules

Par exemple :

module load gromacs/5.0.2-mpi

Si vous utilisez la version GPU, vous devez faire

module unload intel/composer
module load intel/composer/xe_2013_sp1.2.144
module load gromacs/5.0.2-gpu

Pour la version 5.0.4, un seul fichier module existe. Le nom de l'exécutable change en fonction du mode de fonctionnement souhaité :

• mdrun pour la version sans MPI en simple précision
• mdrun_d pour la version sans MPI en double précision
• mdrun_mpi pour la version avec MPI en simple précision
• mdrun_mpi_d pour la version avec MPI en double précision

Les benchmarks suivants ont été réalisés sur une simulation de DHFR (une petite protéine), qui est couramment utilisée pour des benchmarks. Le système contient environ 23000 atomes. Il est possible de paralléliser de deux manières différentes :

• avec MPI, qui est performant pour partager un job au sein d'un ou plusieurs noeuds
• avec openMP, qui peut être performant pour partager des coeurs au sein d'un processus MPI sur un même noeud.

Voici un tableau des performances relevées avec Gromacs 5.0.2 compilé avec les compilateurs intel :

nb_coeurs      ntasks(MPI)     cpus-per-task(openMP)    GPU      Performance(ns/day)
        2               2                          1      0       10.955
        4               4                          1      0       14.817
        8               8                          1      0       21.747
       16              16                          1      0       64.457
       32              32                          1      0      110.067
       64              64                          1      0      156.836
      128             128                          1      0      268.282
      256             256                          1      0      255.346 #ici, on dépasse la limite de 100 atomes par coeur. Ça devrait mieux fonctionner avec un plus gros système
      256             128                          2      0      291.507 # pour un grand nombre de coeurs, il devient intéressant de diminuer le nombre de processus MPI au profit d'openMP
        8               1                          8      1       82.490
        8               2                          4      2       82.217 # la puissance à 2 GPU est limitée par le nombre de coeurs
       16               2                          8      2      118.781
       16               1                         16      1      112.530 # pas d'intérêt d'utiliser les 2 CPU pour 1 GPU, mais on constate également la limite du nombre de CPU.
       

Ne sont présentées ici que les configurations les plus rapides. En effet, sur CPU uniquement, openMP n'est efficace que pour des gros systèmes sur un grand nombre de coeurs. Avec moins de 256 coeurs, on constate une dégradation de performance quel que soit le nombre de threads openMP par processus MPI.

Avec des GPU, c'est différent. Il faut utiliser au moins un processus thread-MPI par GPU. Ensuite, on ajuste le nombre de threads openMP pour obtenir le nombre de coeurs voulu. En pratique, utiliser plus d'un thread-MPI par GPU dégrade la performance.

On constate qu'avec GPU on semble être limité par le nombre de CPU. À noter qu'il n'est pas possible d'utiliser plus que 16 coeurs (la partition Slurm ne contient que le noeud GPU). Ce comportement peut aussi être différent pour des plus gros sytèmes.

#!/bin/bash
#SBATCH --partition=cluster
#SBATCH --qos=cluster
#SBATCH --ntasks=32
#SBATCH --cpus-per-task=1
#SBATCH --threads-per-core=1
#SBATCH --mem-per-cpu=1000
#SBATCH --time=10-00:00:00

module load gromacs 
export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK

WORKDIR="$HOME/scratch/$SLURM_JOB_ID"

MIN=true
grompp=grompp
mdrun="srun mdrun_mpi"

# Directory used to store the results
mkdir $WORKDIR || {
        echo "ERROR Creating the working directory"
        exit 1
}

cp * $WORKDIR
cd $WORKDIR

if [ $MIN = "true" ]; then

  $grompp -f em.mdp -c md.gro -n md.ndx -p md.top -o em.tpr
  $mdrun -s em.tpr -o em.trr -c em.gro -e em.edr -g em.log

  $grompp -f pr.mdp -c em.gro -n md.ndx -p md.top -r em.gro -o pr.tpr
  $mdrun -s pr.tpr -o pr.trr -c pr.gro -e pr.edr -g pr.log

  mv pr.gro 0.gro

fi

$grompp -f md.mdp -c 0.gro -n md.ndx -p md.top -o md.tpr
$mdrun -s md.tpr -o md.trr -x md.xtc -c md_out.gro -e md.edr -g md.log
rm -f md.trr # remove the uncompressed trajectory after the calculation
rm -f \#* # remove backup files

#!/bin/bash
#SBATCH --partition=gpu
#SBATCH --qos=gpu
#SBATCH --gres=gpu:1
#SBATCH --ntasks=1
#SBATCH --cpus-per-task=8
#SBATCH --threads-per-core=1
#SBATCH --mem-per-cpu=1000
#SBATCH --time=7-00:00:00

module load gromacs/5.0.2-gpu
export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK

WORKDIR="$HOME/scratch/$SLURM_JOB_ID"

MIN=true
grompp=grompp
mdrun="mdrun"

# Directory used to store the results
mkdir $WORKDIR || {
        echo "ERROR Creating the working directory"
        exit 1
}

cp * $WORKDIR
cd $WORKDIR

if [ $MIN = "true" ]; then

  $grompp -f em.mdp -c md.gro -n md.ndx -p md.top -o em.tpr
  $mdrun -s em.tpr -o em.trr -c em.gro -e em.edr -g em.log

  $grompp -f pr.mdp -c em.gro -n md.ndx -p md.top -r em.gro -o pr.tpr
  $mdrun -s pr.tpr -o pr.trr -c pr.gro -e pr.edr -g pr.log

  mv pr.gro 0.gro

fi

$grompp -f md.mdp -c 0.gro -n md.ndx -p md.top -o md.tpr
$mdrun -s md.tpr -o md.trr -x md.xtc -c md_out.gro -e md.edr -g md.log
rm -f md.trr # remove the uncompressed trajectory after the calculation
rm -f \#* # remove backup files

#!/bin/bash
#SBATCH --partition=gpu
#SBATCH --qos=gpu
#SBATCH --gres=gpu:2
#SBATCH --ntasks=2
#SBATCH --cpus-per-task=8
#SBATCH --threads-per-core=1
#SBATCH --mem-per-cpu=1000
#SBATCH --time=7-00:00:00

module load gromacs/5.0.2-gpu
export OMP_NUM_THREADS=$SLURM_CPUS_PER_TASK

WORKDIR="$HOME/scratch/$SLURM_JOB_ID"

MIN=true
grompp=grompp
mdrun="mdrun"

# Directory used to store the results
mkdir $WORKDIR || {
        echo "ERROR Creating the working directory"
        exit 1
}

cp * $WORKDIR
cd $WORKDIR

if [ $MIN = "true" ]; then

  $grompp -f em.mdp -c md.gro -n md.ndx -p md.top -o em.tpr
  $mdrun -s em.tpr -o em.trr -c em.gro -e em.edr -g em.log

  $grompp -f pr.mdp -c em.gro -n md.ndx -p md.top -r em.gro -o pr.tpr
  $mdrun -s pr.tpr -o pr.trr -c pr.gro -e pr.edr -g pr.log

  mv pr.gro 0.gro

fi

$grompp -f md.mdp -c 0.gro -n md.ndx -p md.top -o md.tpr
$mdrun -s md.tpr -o md.trr -x md.xtc -c md_out.gro -e md.edr -g md.log
rm -f md.trr # remove the uncompressed trajectory after the calculation
rm -f \#* # remove backup files