wiki:IntegrationOpenMP/EnteteCommandesAda

Version 19 (modified by aclsce, 6 years ago) (diff)

--

Entête des jobs et commandes ada

Cette page décrit les entêtes des jobs sur vargas ainsi que les commandes à lancer pour avoir un exécutable simple ou un couplé.

Remarques générales et info utiles

  • Il y a une classe de job spéciale pour les compilation (durée max. 20h), la classe "compil":
    • Entête du job
      # @ job_type = serial
      # @ class = compil
      
  • Pour des tests rapides (temps "elapsed" plafonné à 30mn, et utilisant jusqu'à 64 coeurs), on peut utiliser la queue "debug":
    • Entête du job
      ### pour un job séquentiel ou OpenMP pur, "job_type = serial" ; "job_type = parallel" pour MPI et mixe MPI/OpenMP
      # @ job_type = parallel
      # @ class = debug
      
  • Si on obtient un plantage à l'exécution avec ce message "error while loading shared libraries: libnetcdff.so.5: cannot open shared object file: No such file or directory", c'est qu'il manque un:
    export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/smplocal/pub/NetCDF/4.1.3/lib:/smplocal/pub/HDF5/1.8.9/seq/lib
    
    A mettre une bonne fois pour toute dans son ~/.bash_login (ou ~/.bashrc), ou sinon dans le corps du job (avant l'exécution du GCM).

Un executable séquentiel

  • Entête du job
    # @ job_type = serial
    
  • Commande
    time ./create_etat0_limit.e
    
  • Remarque: par défaut, la mémoire disponible est de 3.5gb mais on peut demander plus (jusqu'à 20gb) via un " # @ as_limit = 20.0gb " dans l'en-tête du job.

Un executable parallélisé avec OpenMP seulement

  • Entête du job
    # @ job_type = serial
    ## nombre de tâches OpenMP (ici 4)
    # @ parallel_threads = 4
    ### Mémoire (maximum 7.0gb par coeur; par ex. pour 4 threads on peut aller jusqu'à as_limit=28gb)
    # @ as_limit = 7.0gb
    
  • Commande
    # Penser à définir la memoire STACK max. utilisée par les variables privees de chaque thread.
    # (sinon par défaut c'est un tout petit 4M)
    #export KMP_STACKSIZE=200M
    # Il est aussi possible d'utiliser la variable d'environnement OMP_STACKSIZE
    export OMP_STACKSIZE=200M
    
    time ./gcm.e
    
  • Résultat : lance 1 tâche et 4 threads avec le programme : gcm.e
  • Remarque : un message d'erreur à l'exécution du type "forrtl: severe (41): insufficient virtual memory" est un signe d'une mémoire insuffisante (il faudra donc augmenter la valeur de "as_limit").
  • Remarque 2: un message d'erreur à l'exécution du type "Segmentation fault (core dumped)" sans autre sommation est signe d'un "OMP_STACKSIZE" trop faible.

Un executable parallélisé avec MPI seulement

  • Entête du job
    # @ job_type = parallel
    # Nombre de processus demandes (ici 32)
    # @ total_tasks = 32
    
  • Commande
    poe ./gcm.e
    
  • Résultat : poe lance 32 tâches, avec toute le même programme : gcm.e
  • Remarque: La mémoire disponible est de 3.5gb par coeur (donc par tâche MPI pour un job MPI pur), on ne peut pas dépasser cette limite si on demande plus de 64 tâches. Par contre on peut demander jusqu'à 7.0gb par coeur ("# @ as_limit = 7.0gb" dans l'en-tête du job) si on utilise 64 tâches ou moins. Sinon (à tester...) il y a la possibilité comme sur Vargas de demander des "threads" fantômes pour obtenir plus de mémoire (mais attention ce sera facturé!!) en compilant en mode "MPI" seul mais en lancant un job mixte "MPI/OpenMP" suivant le modèle ci-après.
  • Attention: il n'y a que 28 noeuds sur lequels peuvent passer les travaux dits "Larges" (plus de 3.5 Go de memoire par coeur) contre 304 noeuds pour les travaux usuels, donc ne demander plus de 3.5gb par coeur que si c'est impératif (sinon ne pas s'étonner d'attendre plus longtemps que les autres pour que ses jobs passent).

Un executable parallélisé avec MPI et OpenMP

  • Entête du job
    # @ job_type = parallel
    ## nombre de processus demandées
    # @ total_tasks = 16
    ## nombre de tâches par processus
    # @ parallel_threads = 4
    ### Mémoire (si moins de 64 coeurs: maximum 7.0gb par processus MPI; par ex. pour 4 threads par processus, on peut aller jusqu'à as_limit=28gb)
    ### Mémoire (si plus de 64 coeurs: maximum 3.5gb par processus MPI; par ex. pour 4 threads par processus, on peut aller jusqu'à as_limit=14gb)
    # @ as_limit = 28gb
    
  • Commande
    # Penser à définir la memoire STACK max. utilisée par les variables privees de chaque thread.
    # (sinon par défaut c'est un tout petit 4M)
    #export KMP_STACKSIZE=200M
    # Il est aussi possible d'utiliser la variable d'environnement OMP_STACKSIZE
    export OMP_STACKSIZE=200M
    
    poe ./gcm.e
    
  • Résultat : poe lance 16 tâches, avec toute le même programme : gcm.e avec 4 threads chaque
  • Remarque : un message d'erreur à l'exécution du type "forrtl: severe (41): insufficient virtual memory" est un signe d'une mémoire insuffisante (il faudra donc augmenter la valeur de "as_limit").
  • Remarque 2: un message d'erreur à l'exécution du type "Segmentation fault (core dumped)" sans autre sommation est signe d'un "OMP_STACKSIZE" trop faible.
  • Attention: il n'y a que 28 noeuds sur lequels peuvent passer les travaux dits "Larges" (plus de 3.5 Go de memoire par coeur) contre 304 noeuds pour les travaux usuels, donc ne demander plus de 3.5gb par coeur que si c'est impératif (sinon ne pas s'étonner d'attendre plus longtemps que les autres pour que ses jobs passent).

Un couplé avec Oasis sur 1 proc, NEMO sur 5 procs et LMDZ sur 26 procs, MPI seul

  • Entête du job
    # @ total_tasks = 32
    # @ environment = "BATCH_NUM_PROC_TOT=32"
    
  • Commande
     time poe -pgmmodel mpmd -cmdfile ./run_file
    
    • avec run_file contenant, oasis en premier obligatoirement:
      ./oasis
      ./lmdz.x   #===> 26 fois
      ...
      ./opa.xx  #==> 5 fois
      ...
      
  • Résultat : poe lance 32 tâches : 1 oasis, 26 lmdz et 5 opa

Un couplé avec Oasis sur 1 proc, NEMO sur 5 procs et LMDZ sur 12 procs MPI et 2 tâches OpenMP

Le nombre de coeurs réservés pour les tâches OpenMP par process MPI (paramètre @ parallel_threads) est global et s'applique donc à l'ensemble des executables. Il y a donc un surcout de ressources utilisées dû au nombre de coeurs réservés pour chaque process MPI de NEMO et XIOS (lorsqu'il est utilisé en mode serveur). On conseille de mettre 2 tâches OpenMP au maximum. Plus d'information sur la page de l'IDRIS : http://www.idris.fr/ada/ada-exec-mpmd_batch.html#couplage_mpmd_de_codes_hybrides_mpiopenmp

  • Entête du job :
    # @ job_type = parallel
    ## nombre de processus demandées
    # @ total_tasks = 18
    ## nombre de tâches par processus
    # @ parallel_threads = 2
    
  • Commande :
    time poe -pgmmodel mpmd -cmdfile ./run_file
    
    • avec run_file contenant, oasis en premier :
      ./oasis
      ./opa.xx   #==> 5 fois
      ...
      env OMP_NUM_THREADS=2 ./lmdz.x     #====> 12 fois
      ...
      

Entête du couplé IPSLCM5A sur Ada (MPI seul)

#!/usr/bin/ksh
# ######################
# ##   ADA IDRIS   ##
# ######################
# Nom de la requete
# @ job_name = piControl2V
# Type de travail
# @ job_type = parallel
# Fichier de sortie standard
# @ output = Script_Output_piControl2V.000001
# Fichier de sortie erreur (le meme)
# @ error = Script_Output_piControl2V.000001
# Nombre de processus demandes
# @ total_tasks = 32
# @ environment = "BATCH_NUM_PROC_TOT=32"
# Temps CPU max. par processus MPI hh:mm:ss
# @ wall_clock_limit = 10:00:00
# Fin de l entete
# @ queue