Turing : TAU

Description

TAU (Tuning and Analysis Utilities) est un outil graphique d'analyse de performances pour applications parallèles. Il a été développé par l'Université d'Oregon, le LANL et le JSC (Jülich Supercomputing Centre). Il permet d'analyser le comportement et les performances d'une application et d'en identifier facilement les parties critiques.

Versions installées

  • TAU 2.21.4 (version par défaut)

Utilisation

La commande module permet d'accéder à TAU.

Avant de travailler avec cet outil, il faut donc exécuter la commande :

module load tau

L'utilisation de TAU se fait en trois étapes :

  1. Instrumentation de l'application ;
  2. Exécution de l'application instrumentée ;
  3. Analyse/visualisation des résultats.

Instrumentation automatique

TAU fonctionne en modifiant votre application pour insérer ses propres procédures de mesures.

Toute application peut être instrumentée soit automatiquement (sélectivement ou pas), soit manuellement. Seule l'instrumentation automatique d'une application sera abordée dans ce document. Pour la procédure manuelle, référez vous au manuels de TAU.

Pour instrumenter votre application, il suffit de remplacer le nom du compilateur par tau_f90.sh pour un code Fortran90, par tau_cc.sh pour un code C ou par tau_cxx.sh pour un code C++ :

tau_f90.sh my_code.f90

Le choix des fonctionnalités disponibles dans l'application instrumentée se fait via la variable d'environnement TAU_MAKEFILE. Par défaut, elle est positionnée sur Turing à la valeur $TAU_MAKEFILE_DIR/Makefile.tau-bgqtimers-papi-mpi-compensate-pdt (adaptée aux applications MPI pur). Voici la liste de celles qui sont disponibles :

  • Makefile.tau-bgqtimers-papi-mpi-compensate-pdt : pour applications MPI pur ;
  • Makefile.tau-bgqtimers-papi-mpi-compensate-pdt-openmp : pour applications hybride MPI/OpenMP ;
  • Makefile.tau-bgqtimers-papi-mpi-compensate-pdt-openmp-opari : pour applications hybride MPI/OpenMP avec instrumentation des directives OpenMP ;
  • Makefile.tau-memory-bgqtimers-papi-mpi-compensate-pdt : pour applications MPI pur avec mesure de la mémoire heap (mémoire allouée dynamiquement) à chaque appel de fonction/subroutine (attention aux surcoûts) ;
  • Makefile.tau-memory-bgqtimers-papi-mpi-compensate-pdt-openmp : pour applications hybride MPI/OpenMP avec mesure de la mémoire heap (mémoire allouée dynamiquement) à chaque appel de fonction/subroutine (attention aux surcoûts).
  • Makefile.tau-memory-bgqtimers-papi-mpi-compensate-pdt-openmp-opari : pour applications hybride MPI/OpenMP avec mesure de la mémoire heap (mémoire allouée dynamiquement) à chaque appel de fonction/subroutine (attention aux surcoûts) et avec instrumentation des directives OpenMP.

Attention : l'usage de TAU entraîne des surcoûts en temps d'exécution (non négligeable, de l'ordre de 10%, très variable d'une application à l'autre et selon les mesures effectuées), d'occupation mémoire (impact assez faible) et disque (écriture d'au moins un fichier par coeur utilisé).

Instrumentation sélective (semi-automatique)

Il est possible d'instrumenter uniquement les parties du codes qui nous intéressent. Cette approche permet également d'instrumenter certaines boucles (plutôt que les fonctions/routines), de suivre les allocations/désallocations mémoire, ainsi que les appels d'entrées/sorties d'une application.

Pour cela, il faut tout d'abord (avant la compilation), positionner la variable d'environnement TAU_OPTIONS à -optVerbose -optSelectTauFile=select.tau. select.tau est le nom du fichier dans lequel on va mettre les informations sur l'instrumentation pour TAU.

export TAU_OPTIONS="-optVerbose -optSelectTauFile=select.tau"

Voici un exemple de fichier d'instrumentation sélective :

BEGIN_EXCLUDE_LIST
# N'instrumente pas les routines/fonctions contenant INIT dans leur nom
"#INIT#"
END_EXCLUDE_LIST

BEGIN_FILE_EXCLUDE_LIST
# N'instrumente pas les fichiers suivants
"pas_important.f90"
"bla*.c"
END_FILE_EXCLUDE_LIST

BEGIN_INSTRUMENT_SECTION
# Instrumente les routines commencant par BIGLOOP dans le fichier loop_test.f90
loops file="loop_test.f90" routine="BIGLOOP#"
# Instrumente les I/O dans la routine OUTPUT
io routine="OUTPUT"
# Instrumente les allocations/desallocations dans le fichier alloc.f90
memory file="alloc.f90"
END_INSTRUMENT_SECTION

Les différentes sections ne sont pas obligatoires et peuvent être vides. Le symbole # sert de début de commentaire ou d'équivalent à * dans les noms de routines (ne pas utiliser * mais # pour elles). En Fortran, les noms des subroutines doivent être mis en majuscules pour être reconnus par TAU. Plus de détails sont disponibles sur le site web de TAU.

Exécution

L'exécution se fait de façon standard en utilisant l'application instrumentée. Le comportement et les mesures effectuées peuvent être contrôlés via des variables d'environnement. Les principales sont :

  • TAU_CALLPATH et TAU_CALLPATH_DEPTH : pour établir l'arbre des appels (quel sous-programme à appelé quel autre sous-programme et combien de temps ils ont passés). Pour activer cette fonctionnalité : mettre TAU_CALLPATH=1 et préciser la profondeur de l'arbre (par défaut à 2, plus la valeur est grande, plus les surcoûts augmentent) ;
  • TAU_COMM_MATRIX : détermine la matrice de communication MPI de l'application (quels processus communiquent ensembles). A activer avec la valeur 1 (0 par défaut) ;
  • TAU_METRICS : relevé des compteurs hardware avec la bibliothèque PAPI. La liste des compteurs disponibles peut être obtenue à l'aide de la commande papi_avail (disponible en chargeant le module papi). Attention, toutes les combinaisons de compteurs ne sont pas possibles (la commande papi_event_chooser permet de vérifier ce qui est possible). Les noms des compteurs doivent être séparés par le caractère :. Il est conseillé de toujours y ajouter le compteur BGQTIMERS afin de mesurer aussi les durées ;
  • TAU_THROTTLE_NUMCALLS et TAU_THROTTLE_PERCALL : désactive les mesures pour les appels courts et répétés pour réduire les surcoûts. Par défaut, TAU_THROTTLE_NUMCALLS=100000 et TAU_THROTTLE_PERCALL=10  ce qui correspond à une désactivation des mesures pour les appels faits au moins 100.000 fois et qui durent moins de 10 microsecondes. Pour ne jamais désactiver les mesures, mettre TAU_THROTTLE_NUMCALLS à 0 ;
  • PROFILEDIR : permet de changer le répertoire de sortie des mesures (chemin courant par défaut) ;
  • TAU_VERBOSE : activation du mode bavard de TAU (à mettre à 1 pour l'activer, 0 par défaut). Attention, chaque processus va écrire sur la sortie standard ;
  • TAU_TRACE : pour prendre des traces (évolution temporelle de l'application) au lieu d'un profil (à mettre à 1 pour l'activer, 0 par défaut). TAU_TRACEDIR permet de stocker les sorties de traces dans un répertoire quelconque. Attention, la visualisation ne peut se faire avec TAU. Jumpshot (à installer sur votre ordinateur) est un des moyens de visualisation possible (voir la documentation de TAU) ;
  • TAU_COMPENSATE : TAU essaye de déduire des mesures les surcoûts liés à son utilisation. Cette option est active par défaut. Elle peut être désactivée en mettant TAU_COMPENSATE à la valeur 0.

Voici un exemple de job de soumission :

job.ll
# @ job_name = tau_run
# @ job_type = BLUEGENE
# Fichier sortie standard du travail
# @ output = $(job_name).$(jobid)
# Fichier erreur standard du travail
# @ error = $(output)
# Temps elapsed maximum demande
# @ wall_clock_limit = 1:00:00
# Taille bloc d'execution
# @ bg_size = 64
# @ queue
 
runjob --envs "TAU_METRICS=BGQTIMERS" --ranks-per-node 16 --np 1024 : ./my_appli

Analyse/visualisation des résultats

L'analyse des résultats se fait à l'aide de l'interface graphique paraprof. Pour la lancer, il suffit de taper :

module load tau
paraprof

Comme l'instrumentation génère un (ou plusieurs fichiers) par cœur, il est conseillé de générer d'abord une version compactée des résultats avec la commande :

paraprof --pack output.ppk

Les fichiers de mesures (profile.*) peuvent alors être effacés et les résultats visualisés avec la commande :

paraprof output.ppk

TAU

La visualisation passant par une application graphique, il n'est pas toujours commode de l'utiliser directement à partir de la frontale de Turing. Pour contourner ce problème, il est possible d'installer sur un PC sous Linux (ou toute machine UNIX) l'outil de visualisation paraprof.

La commande pprof peut aussi être utilisée pour obtenir un résumé des mesures.

Documentation