Ada : ABINIT

Présentation

ABINIT est un logiciel de chimie quantique fondé sur la méthode DFT (Density Functional Theory).

Il est développé par Xavier Gonze et Jean-Michel Beuken de l'unité de Physico-Chimie et de Physique des Matériaux de l'Université Catholique de Louvain, en Belgique.

La documentation est disponible sur le site Web du logiciel ABINIT.

Disponibilité

Les numéros des versions disponibles sont :

  • 7.0.5 MPI
  • 7.4.1 MPI (version par défaut)
  • 7.4.1 Hybride
  • 7.6.2 Hybride
  • 7.10.4 Hybride
  • 8.2.2 MPI

Les versions parallèles MPI et hybride MPI/OpenMP (le cas échéant) sont installées.

Script de lancement

Version 8.2.2

Cette version a été compilée avec une version du compilateur d'intel qui rend impossible l'utilisation de poe. Il est donc nécessaire d'utiliser l'environnement intel.

job_intel.ll
# @ job_name         = abinit_par
# @ job_type         = mpich
# @ total_tasks      = 32
# @ environment = NB_TASKS=$(total_tasks)
# @ wall_clock_limit = 01:00:00
# @ output           = $(job_name).$(jobid)
# @ error            = $(job_name).$(jobid)
# @ as_limit = 3.5gb
# @ queue
 
### Initialisation de Module ###
##module load abinit/7.10.4
module load intel/2016.4
module load abinit/8.2.2
#
### Echo des commandes ###
set -x
#
### Lancement du calcul ###
mpirun -np ${NB_TASKS} abinit < abinit.files >& abinit.log

Versions antérieures

Voici un exemple de script de lancement en parallélisation hybride pour un calcul exécuté dans le WORKDIR :

job.ll
# @ job_name         = ABINIT
# @ output           = $(job_name).$(jobid)
# @ error            = $(job_name).$(jobid)
# @ job_type         = parallel
# @ total_tasks      = 32
# @ parallel_threads = 4
# @ wall_clock_limit = 1:00:00
# @ queue
 
### Initialisation de Module ###
module load abinit/7.10.4
 
### Echo des commandes ###
set -x
 
### Lancement du calcul ###
poe abinit < abinit.files > fichier.out

Voici un exemple de script de lancement en parallélisation MPI pour un calcul exécuté dans le TMPDIR :

job.ll
# @ job_name         = ABINIT
# @ job_type         = parallel
# @ output           = $(job_name).$(jobid)
# @ error            = $(job_name).$(jobid)
# @ wall_clock_limit = 1:00:00
# @ total_tasks      = 64
# @ queue
 
### Initialisation de Module ###
module load abinit
 
### Echo des commandes ###
set -x
 
### Copie vers le TMPDIR ###
cp ./* $TMPDIR
 
### Lancement du calcul ###
cd $TMPDIR
poe abinit < abinit.files > fichier.out
 
### Copie vers le dossier de soumission ###
cd -
cp $TMPDIR/* .

Vous pouvez aussi vous référer à nos conseils plus généraux sur la soumission en queue sur Ada d'un travail parallélisé avec MPI ou parallélisé en mode mixte MPI/OpenMP.

Paramètres propres au logiciel

Pseudo-potentiels

Deux ensembles complets de pseudo-potentiels pour tout le tableau périodique sont disponibles sur le site Web du logiciel ABINIT.

Fichier abinit.files

Dans les exemples ci-dessus de scripts de lancement, le fichier abinit.files est indispensable. Il contient en effet la liste des fichiers d'entrée, les préfixes pour les fichiers de sortie, ainsi que la liste des pseudo-potentiels pour le calcul. Si ce fichier n'est pas présent en argument de l'exécutable, votre calcul restera bloqué (car le code attend cette liste de fichiers).
Ce fichier est typiquement de la forme :

fichier_entree.in
fichier_de_sortie.out
prefix_fichiers_temp
prefix_fichiers_fonctiond'onde(etc)
prefix_fichiers_log_de_chaque_processus
/workgpfs/rech/xxx/rxxx000/ABINIT/pseudo1.psp
/workgpfs/rech/xxx/rxxx000/ABINIT/pseudo2.psp

Parallélisation par défaut

ABINIT utilise la parallélisation MPI dans de nombreuses parties de son code. Certaines parties peuvent également bénéficier d'une parallélisation OpenMP additionnelle. Par défaut, la parallélisation se fait sur les points k et/ou sur les états de spin.

Pour utiliser au mieux les ressources, il faut alors essayer de choisir un nombre de tâches MPI (ou de cœurs de calcul) multiple du nombre de points k : par exemple, sans spin et pour 60 points k, 30 cœurs de calcul donneront une solution plus rapidement que 32 cœurs. Vous pourrez trouver des informations complémentaires dans les tutoriaux du site ABINIT.

Néanmoins, les autres modes de parallélisation permettent de plus ou moins s'affranchir de ces contraintes, tout en obtenant de meilleures performances.

Parallélisation automatique (versions 7.10+)

Afin d'augmenter significativement les performances, notamment par rapport à la parallélisation par défaut, ABINIT peut déterminer de façon automatique la répartition des cœurs de calcul, qu'il attribue de façon optimale selon les étapes de la simulation.

Pour activer ce mode, il suffit simplement d'écrire dans le fichier d'entrée : AUTOPARAL=1.
La répartition éventuellement déjà présente dans votre fichier doit alors être supprimée ou commentée (mots-clés npkpt, npband, npfft, max_ncpus, mkmem, paral_kgb, etc.).

Parallélisation KGB (versions jusqu'à 7.6)

Pour les calculs à l'état fondamental, il est possible d'obtenir de bonnes performances en utilisant la parallélisation sur les points k (K), les vecteurs d'onde (G) et les bandes (B). Malheureusement, ce mode de parallélisation n'est pas automatique sur les anciennes versions et il est nécessaire d'indiquer le nombre de cœurs attribués pour traiter les points k, les bandes, et les transformées de Fourier (FFT) de façon individuelle. Voici un résumé de la méthode la plus simple, d'autres sont disponibles sur la page dédiée des tutoriaux de ABINIT. Notez que cette méthode fonctionne mieux pour un nombre de cœurs supérieur à 64.

Attention, la procédure décrite ci-dessous est uniquement valable jusqu'à la version 7.4.1. Pour les versions supérieures à 7.4.1, consultez les tutoriaux de ABINIT car la procédure et les mots-clés sont légèrement différents.

  • Dans cette première étape, vous devez indiquer dans votre fichier d'entrée (par exemple abinit.in) : paral_kgb=-nombre_de_cœurs_de_calcul_maximum_souhaité.
    Par exemple, pour un maximum de 512 coeurs :

    paral_kgb=-512
  • Lancez ce calcul sur 1 seul cœur (directive du script de soumission : # @ total_tasks = 1). Ce calcul est très rapide, et consiste seulement à déterminer la configuration de calcul.
  • Le résultat se trouve à la fin du fichier out.log pour nos exemple de jobs dans cette page. La meilleure configuration correspond à la première ligne dans laquelle la valeur de weight est la plus proche de 1.
    Voici un exemple :

     mpi_setup : COMMENT -
     For dataset=   1  a possible choice for less than  512 processors is:
      nproc     npkpt  npspinor    npband     npfft    bandpp    weight
       480       60        1         4         2         1        0.50
       240       60        1         2         2         2        0.25
       240       60        1         4         1         1        1.00
       120       60        1         2         1         2        1.00
  • Il vous suffit alors de récupérer les paramètres optimaux pour votre calcul. Dans cet exemple, en choisissant 240 cœurs de calcul (donc dans votre script de soumission : # @ total_tasks = 240), il faudra indiquer dans votre fichier abinit.in paral_kgb=1 (dans tous les cas, pour activer la parallélisation) ainsi que :

    paral_kgb=1
      
    npkpt=60
    npband=4
    npfft=1

Ceci reste la méthode la plus simple et la plus rapide. En consultant la page dédiée du site ABINIT, vous trouverez la description complète de la détermination précise de la configuration optimale, paramètre par paramètre, mais celle-ci peut s'avérer plus longue et consommatrice de ressources, pour un résultat souvent proche de la méthode simple.