Document Actions
Environnement XLF
Options de compilation pour le compilateur Fortran d'IBM : déboguage, optimisation, profilage, OpenMP, MPI
Compilateur XLF
Variables d'environnement
Messages d'erreur courants
Listings du compilateur
La compilation
Introduction
La compilation consiste à traduire un programme écrit dans un langage de programmation de haut niveau dans un programme en langage machine. L'application qui effectue cette traduction s'appelle un compilateur .Il existe plusieurs commandes pour invoquer le compilateur Fortran, xlf, selon la version du Fortran (77, 90, 95) et le type de programmation (séquentielle, parallèle). La différence principale réside dans les options de compilation prises par défaut.
1. Les commandes de compilation
Les tableaux suivants décrivent ces différentes situations :
| Langage | Commande |
|---|---|
| Fortran77 | xlf |
| Fortran77 + MPI | mpxlf |
| Fortran77 + OpenMP | xlf_r |
| Fortran77 + MPI + OpenMP | mpxlf_r |
| Langage | Commande |
|---|---|
| Fortran90 | xlf90 |
| Fortran90 + MPI | mpxlf90 |
| Fortran90 + OpenMP | xlf90_r |
| Fortran90 + MPI + OpenMP | mpxlf90_r |
| Langage | Commande |
|---|---|
| Fortran95 | xlf95 |
| Fortran95 + MPI | mpxlf95 |
| Fortran95 + OpenMP | xlf95_r |
| Fortran95 + MPI + OpenMP | mpxlf95_r |
L'extension _r signifie que le compilateur supporte les threads selon la norme POSIX qui sont par exemple employées pour la parallélisation par OpenMP et qu'il est aussi threadsafe.
Le préfixe mp signifie que le compilateur définit les chemins pour chercher les fichiers et bibliothèques spécifiques à MPI (Messages Passing Interface).
Il faut noter que par défaut l'extension des fichiers source Fortran est .f .
Remarque importante :
Pour qu'un programme MPI puisse être checkpointé, il doit impérativement être compilé par la version thread safe du compilateur, i.e. mpxlf_r ou mpxlf90_r ou mpxlf95_r.
2. Le pré-compilateur cpp
Si le nom du fichier à compiler est suffixé par .F au lieu de .f alors le compilateur xlf appelle dans une première phase le pré-compilateur cpp qui analyse les sections de code délimitées par des directives et permet ainsi de faire une compilation conditionnelle. Les directives les plus usitées sont :
#define
#undef
#if
#ifdef
#ifndef
#else
#elif
#endif
#include
On peut passer des options au pré-compilateur au travers du compilateur à l'aide de l'option -WF suivie de l'argument. Par exemple -WF,-DAIXV4 transmet le symbole AIXV4 au pré-processeur qui le reconnait comme étant défini.
L'option -d permet de conserver les fichiers source pré-compilés par cpp plutôt que de les effacer. Pour cela, le fichier file.F génère le fichier Ffile.f.
Des options qui contrôlent les entrées fournies au compilateur
Les options suivantes affectent de manière importante ce qui est envoyé au compilateur : les fichiers source traités, la sensibilité aux majuscules / minuscules, la sensibilité aux positions dans les colonnes.
- 1. Option -Idir
- 2. Options -qdirective[=directive_list] et -qnodirective[=directive_list]
- 3. Option -qfixed[=right_margin]
- 4. Option -qfree[=f90]
- 5. Option -qsuffix={suboptions}
- 6. Options -qmixed et -qnomixed
- 7. Proposition d'options
1. Option -Idir
Cette option ajoute le répertoire dir dans le chemin de recherche des fichiers à inclure, fichiers headers (.h) et fichiers modules (.mod). Le chemin par défaut comprend les répertoires suivants qui sont parcourus dans cet ordre :- répertoire courant,
- répertoire du fichier source,
- répertoire /usr/include.
2. Options -qdirective[=directive_list] et -qnodirective[=directive_list]
Ces options spécifient des séquences de caractères, aussi appelées sentinelles, qui permettent au compilateur d'identifier des lignes de commentaires comme étant des directives. Par exemple, les sentinelles OpenMP, $OMP, ne sont reconnues que si l'option -qsmp=omp est fournie au compilateur.On peut ainsi définir des directives dont la prise en compte est décidée à la compilation. Plusieurs de ces options peuvent apparaitre dans la séquence de compilation, elles sont "additives".
L'option par défaut est -qnodirective.
Retour au début de la section.3. Option -qfixed[=right_margin]
Cette option indique au compilateur que le fichier source en entrée est au format fixe. En option, on peut spécifier la longueur maximale des lignes (right_margin) sans dépasser la limite de 132 caractères par ligne.-qfixed=72 est le défaut pour xlf, xlf_r, mpxlf, mpxlf.
Retour au début de la section.4. Option -qfree[=f90]
Cette option indique au compilateur que le fichier source en entrée est au format libre. Le format libre défini pour le fortran 90 s'applique aussi au Fortran 95.-qfree=f90 est le défaut pour xlf90, xlf90_r, mpxlf90, mpxlf90_r ainsi que pour xlf95, xlf95_r, mpxlf95, mpxlf95_r .
Retour au début de la section.5. Option -qsuffix={suboptions}
Cette option permet de spécifier le suffixe des fichiers source dans la ligne de compilation. Elle permet de limiter le nombre de modifications à effectuer dans le fichier Makefile.Ses arguments sont les suivants :
- f=suffix : suffix représente le nouveau suffixe des fichiers source Fortran ;
- o=suffix : suffix représente le nouveau suffixe des fichiers objet ;
- s=suffix : suffix représente le nouveau suffixe des fichiers source assembleur ;
- cpp=suffix : suffix représente le nouveau suffixe des fichiers source pour le pré-processeur.
xlf fichier.f90 -qsuffix=f=f90:cpp=F90
a pour effet d'invoquer le pré-compilateur cpp sur les fichiers ayant le suffixe .F90 et le compilateur xlf sur les fichiers ayant le suffixe .f90. Retour au début de la section.
6. Options -qmixed et -qnomixed
Ces options rendent ou non le compilateur attentif aux majuscules / minuscules.-qnomixed est l'option par défaut.
Retour au début de la section.7. Proposition d'options pour contrôler les entrées fournies au compilateur
Une séquence basique d'options pour un programme en Fortran 77 pourrait être :Une séquence basique d'options pour un programme en Fortran 90 pourrait être :
Voir aussi la rubrique Exemples de fichiers de compilation
Des options qui contrôlent la localisation des fichiers générés par le compilateur
Les options suivantes spécifient les noms ou les répertoires de stockage des fichiers générés.
1. Option -d
L'option -d permet de conserver les fichiers source pré-compilés par cpp plutôt que de les effacer. Pour cela, le fichier file.F génère le fichier Ffile.f. Retour au début de la section .2. Option -o name
L'option -o permet de spécifier un nom pour le fichier objet, l'exécutable ou le fichier source assembleur. Le défaut est -o a.out . Retour au début de la section .3. Option -qmoddir=dir
Cette option permet de préciser le répertoire où les fichiers modules (.mod) sont écrits.Par défaut, les fichiers .mod sont placés dans le répertoire courant.
Retour au début de la section .4. Proposition d'options pour contrôler la localisation des fichiers générés par le compilateur
Une séquence basique d'options pour un programme en Fortran 77 pourrait être :Une séquence basique d'options pour un programme en Fortran 90 pourrait être :
L'option -I est décrite dans la section Des options qui contrôlent les entrées fournies au compilateur.
Voir aussi la rubrique Exemples de fichiers de compilation
Des options qui contrôlent le listing et les messages
Les options suivantes déterminent si le compilateur génère des fichiers listing (extension .lst), quels types d'information y sont mis et ce qu'il fait en cas d'erreur détectée.
- 1. Option -#
- 2. Option -qattr[=full] et -qnoattr
- 3. Option -qflag=listing_severity:terminal_severity
- 4. Options -qlist et -qnolist
- 5. Options -qlistopt et -qnolistopt
- 6. Option -qnoprint
- 7. Options -qreport[=smplist|hotlist] et -qnoreport
- 8. Options -qsource et -qnosource
- 9. Options -qxref[=full] et -qnoxref
- 10. Options -v et -V
- 11. Options -qsuppress=nnnn-mmm[:nnn-mmmm] et -qnosuppress
- 12. Proposition d'options
1. Option -#
Cette option génère des informations sur la progression de la compilation sans l'effectuer réellement.Elle permet de connaitre les fichiers impliqués dans une compilation particulière et les options activées pour chaque phase.
Il n'y a pas d'affichage par défaut.
Retour au début de la section.2. Option -qattr[=full] et -qnoattr
Ces options spécifient si des informations liées aux arguments transmis aux sous-programmes sont mises ou pas dans le listing généré.L'attribut full insère ces informations aussi pour les arguments transmis mais non référencés.
-qnoattr est l'option par défaut.
Retour au début de la section.3. Option -qflag=listing_severity:terminal_severity
En cas d'utilisation de cette option, on doit spécifier ces deux arguments. Ils limitent l'affichage de messages à ceux du niveau spécifié ou au-delà. Ainsi :- listing_severity s'applique aux messages inclus dans les fichiers listing (extension .lst) ;
- terminal_severity s'applique aux messages envoyées sur le terminal.
Les niveaux de sévérité, par ordre croissant, sont :
- i (informational messages) : messages d'information. Ils expliquent des choses à savoir mais en général ils ne demandent pas de réaction en retour ;
- l (language-level messages) : messages liés au langage comme ceux produits par -qlanglvl . Ils indiquent des constructions potentiellement non portables ;
- w (warning messages) : messages d'avertissement. Ils indiquent des possibilités d'erreur qui peuvent nécessiter une réaction, cependant le programme est encore correct ;
- e (error messages) : messages d'erreur. Ils indiquent des erreurs qui nécessitent une réaction pour que le programme soit correct mais le programme peut peut-être encore être exécuté ;
- s (severe error messages) : messages d'erreur sévère. Ils indiquent des erreurs qui nécessitent une réaction pour que le programme soit correct et le programme plantera à l'exécution s'il atteint cet endroit ;
- u (unrecoverable error messages) : message d'erreur irrécupérable. Ils indiquent des erreurs qui empêchent le programme de continuer. Elles nécessitent une action pour poursuivre la compilation.
4.Options -qlist et -qnolist
Ces options spécifient si la partie objet doit être incluse ou pas dans le listing généré.Ces informations peuvent contribuer à comprendre les caractéristiques de performance du code objet et à diagnostiquer des problèmes d'exécution.
-qnolist est l'option par défaut.
Retour au début de la section .5.Options -qlistopt et -qnolistopt
Ces options spécifient si l'état de chaque option du compilateur doit être inclus dans le listing généré ou bien si seules certaines options sont concernées. Il s'agit alors des options présentes sur la ligne de commande et un certain nombre d'options toujours présentes dans le fichier listing.Les options toujours affichées sont :
- toutes les options que l'on peut activer/désactiver et qui sont activées ;
- toutes les options que l'on peut activer/désactiver et qui sont désactivées ;
- toutes les options qui prennent des arguments numériques arbitraires;
- toutes les options qui ont plusieurs arguments.
On peut les utiliser en phase de déboguage et en phase de recherche de performances : dans le premier cas pour savoir si les problèmes surviennent avec une combinaison particulière d'options et dans le second cas pour garder une trace des options activées pour une compilation particulière. -qnolistopt est l'option par défaut.
Retour au début de la section .6.Option -qnoprint
Cette option supprime la création du fichier listing quelles que soient les autres options présentes. Retour au début de la section .7. Options -qreport[=smplist|hotlist] et -qnoreport
Ces options spécifient si des comptes-rendus sur la parallélisation du programme et l'optimisation des boucles sont produits.On peut utiliser l'argument smplist pour déboguer des programmes SMP ou affiner leurs performances en examinant les transformations à bas niveau. Il fournit aussi des informations sur les boucles non parallélisées.
On peut utiliser l'argument hotlist pour générer un compte-rendu sur les transformations des boucles.
L'argument smplist produit un listing pseudo-Fortran avant les optimisations de boucles qui contient des informations sur les structures qui peuvent être modifiées pour
améliorer les performances. On peut voir comment le programme traite les données et la parallélisation automatique des boucles.
Les commentaires au sein du listing donnent les correspondances entre le code parallèle et le code source initial. Il fournit aussi des informations sur les boucles non parallélisées. Ce compte-rendu est construit si l'option -qsmp est présente.
L'argument hotlist produit un listing pseudo-Fortran qui montre comment les boucles sont transformées. De plus, cet argument est celui pris par défaut si l'option -qreport apparait seule.
-qnoreport est l'option par défaut.
8. Options -qsource et -qnosource
Ces options spécifient si la partie source doit être incluse ou pas dans le listing généré.Si c'est le cas, on obtient toutes les lignes sur lesquelles le compilateur a détecté un problème.
-qnosource est l'option par défaut.
Retour au début de la section .9. Options -qxref[=full] et -qnoxref
Ces options spécifient si la partie référence croisée doit être incluse ou pas dans le listing généré.Si on spécifie -qxref, seuls les identifiants référencés sont pris en compte.
Si on spécifie -qxref=full, tous les identifiants sont pris en compte.
On peut utiliser ce listing durant le déboguage pour localiser des problèmes comme l'utilisation de variables non définies.
-qnoxref est l'option par défaut.
Retour au début de la section .10. Options -v et -V
L'option -v génère des informations sur la progression de la compilation en temps réel.Elle permet de connaitre les fichiers impliqués dans une compilation particulière, les options activées pour chaque phase et voir jusqu'où elle arrive en cas d'échec.
L'option -V fait de même mais les commandes affichées peuvent être utilisées dans des "copier/coller".
Il n'y a pas d'affichage par défaut.
Retour au début de la section .
11. Options -qsuppress=nnnn-mmm[:nnn-mmmm] et -qnosuppress
Ces options spécifient si le compilateur supprime ou non l'affichage de messages lors de la compilation, messages choisis par l'utilisateur. Les messages ont un numéro, sous la forme nnn-mmmm.L'option par défaut est -qnosuppress.
Retour au début de la section .12. Proposition d'options qui contrôlent le listing et les messages
Une séquence basique d'options pour un programme Fortran sans OpenMP pourrait être :Une séquence basique d'options pour un programme Fortran avec OpenMP pourrait être :
Voir aussi la rubrique Exemples de fichiers de compilation
Des options qui contrôlent les limites du compilateur
Les options suivantes contrôlent le mode d'adressage et certaines limites du compilateur.
1. Options -q32 et -q64
Ces options provoque la création par la compilation de fichiers objet en mode d'adressage 32 bits ou 64 bits. Par défaut, il s'agit le mode 32 bits est choisi.Le passage du mode d'adressage 32 à 64 bits nécessite une recompilation complète du programme concerné.
NB :
De plus, ce passage a une incidence sur les quantités mémoire que peuvent occuper la stack et le heap. En mode 64 bits, ils peuvent occuper plusieurs millions de Go de mémoire, donc il ne faut plus spécifier les options -bmaxdata et -bmaxstack. Retour au début de la section .
2. -qmaxmem=Kbytes
Cette option limite le volume mémoire maximal que le compilateur peut allouer durant la phase de compilation. Une valeur -1 indique qu'il peut prendre toute la mémoire dont il a besoin.Par défaut, la valeur est 2048. Pour le niveau d'optimisation -O3, elle devient -1.
Retour au début de la section .3. -Wcomponent,options
Cette option du compilateur permet de transmettre des options à un outil utilisé durant la compilation.Les initiales suivantes désignent l'outil destinataire :
- p : un préprocesseur pour l'optimisation;
- F : le préprocesseur C, cpp;
- c : le compilateur;
- d : le désassembleur;
- I : l'analyseur interprocédural;
- a : l'assembleur;
- z : l'éditeur de liens rapide (binder);
- l : l'éditeur de liens (linker);
Des options de portabilité
Les options suivantes permettent de maintenir la compatibilié pour les programmes arrivant au compilateur xlf si la qualité du source n'est pas satisfaisante.
- 1. Option -qautodbl[=setting]
- 2. Options -qdpc[=e]
- 3. Option -qextern=names
- 4. Options -qextname et -qnoextname
- 5. Option -qintsize=bytes
- 6. Options -qnullterm et -qnonullterm
- 7. Option -qrealsize=bytes
- 8. Options -qsave et -qnosave
- 9. Options -qundef et -qnoundef
- 10.Proposition d'options
1. Option -qautodbl[=setting]
Cette option procure un moyen automatique de conversion des calculs flottants simple précision en calculs flottants double précision voire en quadruple (précision étendue). Plusieurs stratégies sont proposées pour préserver les liens entre les objets convertis ou paddés.Le padding consiste à aligner le début de chaque variable sur une adresse mémoire multiple de 8 pour plus d'efficacité.
Cette option utilise un argument parmi les suivants :
- dbl4 : conversion des REAL(4) en REAL(8) et conversion des COMPLEX(4) en COMPLEX(8) ;
- dbl8 : conversion des REAL(8) en REAL(16) et conversion des COMPLEX(8) en COMPLEX(16) ;
- dbl : idem que dbl4 et dbl8 ;
- dblpad4 : idem que dbl4 et aligne les autres données ;
- dblpad8 : idem que dbl4 et aligne les autres données ;
- dblpad : idem que dblpad4 et dblpad8 ;
- none : disposition par défaut.
2. Options -qdpc[=e]
Cette option permet d'augmenter la précision des constantes réelles numériques lors du portage de codes.La forme sans argument, -qdpc, ne concerne que les constante basiques qui sont traitées comme des constantes double précision; la forme avec l'argument, -qdpc=e concerne aussi les constantes avec un exposant (E+0x) qui sont alors traitées comme des constantes double précision.
Cette option n'affecte pas les constantes avec un paramètre kind.
-qnodpc est l'option par défaut.
Retour au début de la section .3. Option -qextern=names
Cette option permet d'appeler des routines écrites par le développeur au lien des routines intrinsèques du XL Fortran pour lesquelles un conflit de noms apparait. Retour au début de la section .4. Options -qextname=symbol[:symbol] et -qnoextname
Cette option ajoute un caractère '_' (souligné) à la fin des objets globaux des codes venant de systèmes où la présence ou l'absence sont une convention.Cela s'applique à tous les externes (y compris les noms de fonctions et subroutines), cette option lorsqu'elle est utilisée doit l'être pour la totalité d'un code et des bibliothèques qu'il utilise. Pour quelques noms seulement, on peut utiliser à sa place l'option -brename de l'éditeur des liens.
Par exemple, les routines flush et etime utilisées couramment dans les programmes Fortran nécessitent ce caractère en fin de mot pour qu'ils soient reconnus.
-qnoextname est l'option par défaut.
Retour au début de la section .5. Option -qintsize=bytes
Cette option permet de spécifier la taille par défaut des variables de type INTEGER et LOGICAL.La taille peut être 2, 4 ou 8.
Cela s'applique aux variables locales et globales, aux FUNCTIONS.
-qintsize=4 est l'option par défaut.
Retour au début de la section .6. Options -qnullterm et -qnonullterm
Cette option permet d'alouter un caractère nul (code ASCII 0) à la fin d'une chaine de caractères constante.Cela peut être utile dans le cas d'utilisation de fonctions en C.
-qnonullterm est l'option par défaut.
Retour au début de la section .7. Option -qrealsize=bytes
Cette option permet de spécifier la taille par défaut des variables de type REAL, DOUBLE PRECISION, COMPLEX et DOUBLE COMPLEX.La taille peut être 4 ou 8.
Cela s'applique aux variables locales et globales, aux FUNCTIONS.
Dans le cas de FUNCTIONS intrinsèques, si l'argument et la donnée renvoyées n'ont pas de type déclarés alors cette option peut les modifier.
-qrealsize=4 est l'option par défaut.
Retour au début de la section .8. Options -qsave et -qnosave
Ces options permettent de spécifier le type de stockage pour les variables locales des sous-programmes : -qsave met le stockage statique par défaut (dans la pile ou stack) alors que -qnostatic met le stockage dynamique par défaut (dans le tas ou heap).Un stockage statique signifie un emplacement mémoire alloué lors de la compilation, qui reste donc le même pour toute l'exécution.
Un stockage dynamique signifie un emplacement alloué à l'entrée du sous-programme, qui n'est donc pas le même si le sous-programme est appelé plusieurs fois.
-qsave est le défaut pour xlf et xlf_r .
-qnosave est le défaut pour xlf90, xlf90_r, xlf95 et xlf95_r.
9. Options -qundef et -qnoundef
Ces options permettent de spécifier si la déclaration implicite des variables est autorisée ou non.-qundef a le même effet que la déclaration IMPLICIT NONE.
-qnoundef est l'option par défaut.
Retour au début de la section .10.Proposition d'options de portabilité
Une séquence basique d'options pour un programme Fortran pourrait être :
Voir aussi la rubrique Exemples de fichiers de compilation
Des options de déboguage
Les options suivantes aident à éviter, détecter et corriger des problèmes dans les programmes Fortran.
- 1. Options -qcheck et -qnocheck
- 2. Options -qdlines et -qnodlines
- 3. Options -qdbg et -qnodbg
- 4. Options -qextchk et -qnoextchk
- 5. Options -qflttrap[=suboptions] et -qnoflttrap
- 6. Options -qfullpath et -qnofullpath
- 7. Option -qhalt=sev
- 8. Options -qinitauto[=hexvalue] et -qnoinitauto
- 9. Options -qinit=f90ptr
- 10. Option -qlanglvl=lang
- 11. Option -qsigtrap=trap_handler
- 12. Option -qwarn64 -qnowarn64
- 13. Proposition d'options de déboguage
1. Options -qcheck et -qnocheck
Ces options vérifient ou non chaque référence faite à un élément de tableau, une section de tableau ou un élément de chaines de caractères.Les références hors des bornes permises génèrent une erreur severe à la compilation et un signal SIGTRAP lors de l'exécution.
Le défaut est -qnocheck.
Retour au début de la section .2. Options -qdlines et -qnodlines
Ces options spécifient si les lignes au format fixe commençant par la lettre D en première colonne, sont compilées ou traitées comme des commentaires.-qnodlines est l'option par défaut.
Retour au début de la section .3. Options -qdbg et -qnodbg
Ces options ajoutent ou non des informations sur les symboles (variables locales, arguments transmis, correspondance code assembleur / lignes du fichier source, ...) dans le code généré qui peuvent ensuite être utilisées par un débogueur symbolique comme dbx.-qdbg peut aussi être écrite sous la forme simplifiée -g.
-qnodbg est l'option par défaut.
Retour au début de la section .4. Options -qextchk et -qnoextchk
Ces options mettent en place ou non les informations nécessaires à la vérification des types des données pour les blocs common, les définitions des procédures, les appels aux procédures et les modules. Par la suite, l'éditeur de liens, peut détecter des incohérences entre les différentes unités compilées.-qnoextchk est l'option par défaut.
Retour au début de la section.5. Options -qflttrap[=suboptions] et -qnoflttrap
Ces options déterminent quels types d'exception flottante sont détectées lors de l'exécution. Le programme reçoit un signal SIGTRAP lorsque l'exception correspondante survient.Les arguments transmis à cette option sont parmi :
- OVerflow : détecte et trappe les overflows (nombres trop grands) si la recherche des exceptions est activée;
- UNDerflow : détecte et trappe les underflows (nombres subnormaux) si la recherche des exceptions est activée;
- ZEROdivide : détecte et trappe les divisions flottantes par zéro si la recherche des exceptions est activée;
- INValid : détecte et trappe les opérations flottantes invalides si la recherche des exceptions est activée;
- INEXact : détecte et trappe les résultats flottants inexacts si la recherche des exceptions est activée ; comme ils sont très fréquents, on ne devrait pas utiliser cet argument;
- ENable : active la recherche des exceptions et permet au programme de générer un signal SIGTRAP ; cet argument est nécessaire si on souhaite détecter les exceptions sans devoir modifier son code source (ajout d'appels à des routines spécifiques de gestion des registres flottants comme fpsets, fpgets et fpstats);
- IMPrecise : recherche les exceptions spécifiées uniquement lors de l'entrée et de la sortie des sous-programmes.
-qflttrap=ov:und:zero:inv:en.
On peut aussi procéder en deux étapes :
- -qflttrap=ov:und:zero:inv:en:imp pour provoquer les tests et les arrêts uniquement en sortie de sous-programmes (gain en temps)
- -qflttrap=ov:und:zero:inv:en pour recompiler le sous-programme fautif et localiser précisément l'origine du problème.
Une restriction concerne la fonction sqrt (racine carrée) dans le cas d'exceptions de type inv car elles ne sont pas signalées. Dans ce cas il faut renseigner la variable d'environnement suivante :
setenv SQRT_EXCEPTION 3.1 en C_shell,
ou
export SQRT_EXCEPTION=3.1 en korn shell.
6. Options -qfullpath et -qnofullpath
Ces options ajoutent ou non le chemin complet, ou absolu, des fichiers sources et headers dans les fichiers objets compilés.Ces options sont utiles pour le déboguage et le profilage.
-qnofullpath est l'option par défaut.
Retour au début de la section .7. Option -qhalt=sev
Cette option permet d'arrêter la compilation selon que le niveau de sévérité soit atteint ou dépassé par un message lors de la compilation. Dans ce cas, aucun fichier objet, exécutable ou assembleur n'est crée.Le niveau de sévérité, sev, est l'une des lettres suivantes :
- i (informational messages) : messages d'information. Ils expliquent des choses à savoir mais en général ils ne demandent pas de réaction en retour ;
- l (language-level messages) : messages liés au langage comme ceux produits par -qlanglvl (voir ci-dessous). Ils indiquent des constructions potentiellement non portables ;
- w (warning messages) : messages d'avertissement. Ils indiquent des possibilités d'erreur qui peuvent nécessiter une réaction, cependant le programme est encore correct ;
- e (error messages) : messages d'erreur. Ils indiquent des erreurs qui nécessitent une réaction pour que le programme soit correct mais le programme peut peut-être encore être exécuté ;
- s (severe error messages) : messages d'erreur sévère. Ils indiquent des erreurs qui nécessitent une réaction pour que le programme soit correct et le programme plantera à l'exécution s'il atteint cet endroit ;
- u (unrecoverable error messages) : message d'erreur irrécupérable. Ils indiquent des erreurs qui empêchent le programme de continuer. Elles nécessitent une action pour poursuivre la compilation.
- q : ne s'arrête jamais, quelle que soit la sévérité des erreurs rencontrées.
-qhalt=s est l'option par défaut; cela inhibe la création de tout fichier objet si la compilation échoue.
Retour au début de la section.8. Options -qinitauto[=hexvalue] et -qnoinitauto
Ces options agissent sur l'initialisation des variables automatiques à une valeur particulière, hexvalue. Cela peut être utile d'initialiser les variables REAL avec des NaNS et ensuite d'identifier les références aux variables REAL non initialisées lors de l'exécution.La valeur hexvalue mise à FF initialise les variables de type REAL et COMPLEX à -NaNQ, soit "Not a Number négatif".
-qnoinitauto est l'option par défaut.
Si l'on utilise -qinitauto sans l'argument hexvalue, alors le compilateur initialise les données automatiques à zéro. Retour au début de la section .
9. Options -qinit=f90ptr
Cette option spécifie que l'état initial des pointeurs Fortran 90 (et 95) est nul, i.e. les pointeurs sont désassociés. Cela permet de localiser des problèmes d'utilisation de pointeurs avant leur définition. Retour au début de la section .10. Option -qlanglvl=lang
Cette option permet de spécifier un langage de référence pour valider ou non la conformance de fichiers source. Cela est utile lors du portage de codes pour détecter dès la compilation les violations possibles de la norme Fortran.En cas d'écart à la norme souhaitée, le compilateur génère un message d'erreur de sévérité l.
Les arguments de cette options de compilation sont :
- 77std : standard Fortran 77 ANSI, signale le reste comme erreur ;
- 90std : standard Fortran 90 ISO, signale le reste comme erreur ;
- 90pure : idem que 90std mais signale les éléments Fortran 90 obsolètes ;
- 90ext : argument obsolète équivalent à extended ;
- 95std : standard Fortran 95 ISO, signale le reste comme erreur ;
- 95pure : idem que 95std mais signale les éléments Fortran 95 obsolètes ;
- extended : accepte tout le Fortran95, toutes ses extensions ; inhibe la vérification linguistique.
11. Option-qsigtrap=trap_handler
Cette option permet de spécifier le gestionnaire d'exceptions flottantes pour traiter les signaux SIGTRAP.Sans argument, le gestionnaire standard xl_ _trce est employé, sinon on spécifie celui que l'on souhaite à l'aide de cette option.
Cette option empêche donc la création de fichier core.
Retour au début de la section .12. Option -qwarn64 -qnowarn64
Cette option permet de détecter la troncature d'un pointeur entier (8 octets) sur 4 octets. Cela peut poser des problèmes lors du passage de 32 bits à 64 bits.-qnowarn64 est l'option par défaut.
Retour au début de la section .13. Proposition d'options de déboguage
Une séquence basique d'options pour déboguer un programme Fortran pourrait être :Les options -qnooptimize et -qfloat=nans sont décrites dans la section Des options d'optimisation.
Voir aussi la rubrique Exemples de fichiers de compilation
Des options d'optimisation
Les options suivantes permettent d'augmenter les performances des programmes en activant divers optimiseurs ou d'effectuer leur analyse.
- 1. Option -qoptimize[=level] et -qnooptimize
- 2. Option -p[g]
- 3. Options -Q -Q[!] -Q[+names] -Q[-names]
- 4. Option -qalias{[no]aryovrlp|[no]intptr|[no]pteovrlp|[no]std}
- 5. Option -qarch=architecture
- 6. Option -qcache=auto
- 7. Options -qfdpr et -qnofdpr
- 8. Options -qhot[=suboptions] et -qnohot
- 9. Option -qipa[=suboptions]
- 10. Options -qlargepage et -qnolargepage
- 11. Option -qpdf{1|2}
- 12. Options -qsmp et -qnosmp
- 13. Options -qstrict et -qnostrict
- 14. Options -qstrictieeemod et -qnostrictieeemod
- 15. Option -qthreaded
- 16. Option -qtune=implementation
- 17. Options -qunroll[=auto|yes] et -qnounroll
- 18. Option -qfloat=options
- 19. Option -qieee={Near(défaut)|Minus|Plus|Zero}
- 20. Options -qzerosize et -qnozerosize
- 21. Proposition d'options d'optimisation
1. Option -qoptimize[=level] et -qnooptimize
Cette option permet de spécifier le niveau d'optimisation du code généré. L'option -qnooptimize est l'option par défaut et inhibe les optimisations ; elle doit être réservée au déboguage et à la validation de codes.De là, on utilise un niveau d'optimisation qui dépend de la stabilité numérique des algorithmes : si on gagne du temps, il ne faut pas perdre de la précision.
-O est une abbréviation de -qoptimize.
Les différents niveaux d'optimisation sont :
- -O2 : niveau d'optimisation qui n'affecte pas la qualité numérique des résultats ;
- -O3 : optimisations supplémentaires qui peuvent affecter la sémentique du programme. Ce niveau d'optimisation active les arguments flint et rsqrt de l'option -qfloat et fixe -qmaxmem=-1 ;
- -O4 : optimisations agressives du code source. Les options suivantes sont activées :
-qhot, -qipa, -O3 (avec ses attributs), -qarch=auto, -qtune=auto et -qcache=auto ; - -O5 : identique au niveau d'optimisation -O4 mais il implique -qipa=level=2.
2. Option -p[g]
Cette option prépare le programme au profilage.Lors de l'exécution du programme, le fichier mon.out est construit et contient des informations de profilage. La commande prof permet d'analyser ce fichier.
L'option -pg est similaire à -p mais le fichier produit, gmon.out, contient plus d'informations. La commande gprof permet d'analyser ce fichier.
Pour ces deux options, il est recommandé de spécifier également l'option -qfullpath pour visualiser les résultats avec l'interface graphique xprofiler.
Retour au début de la section .3. Options -Q -Q[!] -Q[+names] -Q[-names]
Ces options permettent respectivement de spécifier si des routines peuvent être inlinées, de donner une liste de routines à ou à ne pas inliner. Ainsi :- -Q : n'affecte une routine que si le sous-programme appelant et le sous-programme appelés sont dans le même fichier source (ou liés par des directives INCLUDE). Pour traiter le cas de fichiers différents, il faut utiliser l'option -qipa (voir ci-dessous) ;
- -Q+names : force l'inlining des routines en argument ;
- -Q-names : interdit l'inlining des routines en argument ;
- -Q! : inhibe l'inlining.
4. Option -qalias{[no]aryovrlp|[no]intptr|[no]pteovrlp|[no]std}
Cette option indique au compilateur le type d'aliasing utilisé dans le code. Le compilateur limite la portée de certaines optimisations lorsque plusieurs noms peuvent correspondre à la même zone de stockage (ils sont aliasés). Les arguments sont les suivants :- aryovrlp | noaryovrlp : ils indiquent si les unités de compilation contiennent ou non des assignements dans des tableaux pour des tableaux aliasés. Dans la négative, il faut spécifier noaryovrlp ;
- intptr | nointptr : ils indiquent si les unités de compilation contiennent ou non des pointeurs entiers. Dans l'affirmative, il faut spécifier intptr ;
- pteovrlp | nopteovrlp : ils indiquent si deux variables peuvent contenir l'adresse mémoire d'une même zone de stockage. Dans la négative, il faut spécifier nopteovrlp ;
- std | nostd : ils indiquent si les unités de compilation contiennent ou non de l'aliasing hors norme. Dans l'affirmative, il faut spécifier nostd .
5. Option -qarch=architecture
Cette option contrôle le jeu d'instructions qui est employé pour générer le code. Cela peut améliorer les performances mais le code ne pourra alors plus s'exécuter que sur des architectures spécifiques. Il existe différentes options, mais seules deux nous intéressent réellement :- auto : détection automatique de l'architecture sur laquelle a lieu la compilation. Cela suppose que l'environnement d'exécution est le même que l'environnement de compilation ;
- pwr4 : le code compilé peut être exécuté sur n'importe quelle plate-forme à base de processeurs Power4.
- pwr5 : le code compilé peut être exécuté sur n'importe quelle plate-forme à base de processeurs Power5.
6. Option -qcache=auto
Cette option permet de spécifier la configuration du cache des processeurs de la machine d'exécution. Soit on donne les informations techniques des niveaux de cache soit on le laisse détecter la configuration matérielle ce qui est le plus sûr. Ainsi en cas d'utilisation, il vaut mieux mettre -qcache=auto.Il faut noter que son utilisation n'a d'effet que si l'option -qhot (voir ci-dessous) est présente.
Retour au début de la section .7. Options -qfdpr et -qnofdpr
L'option -qfdpr construit au cours de l'exécution du programme cible un fichier objet avec des informations que l'utilitaire fdpr utilise pour optimiser le fichier exécutable. Son usage ne garantit toutefois pas l'obtention de meilleures performances ou des résultats strictement identiques.Seuls les sous-programmes compilés avec cette option vont profiter de l'optimisation.
Son usage est similaire à celui de l'option -qpdf. On peut aussi consulter la manpage de fdpr. L'option par défaut est -qnofdpr.
Retour au début de la section .8. Options -qhot[=suboptions] et -qnohot
L'option -qhot a plusieurs actions ; elle permet notamment d'effectuer ou non des transformations sur les boucles et les fonctions intrinsèques tableaux durant l'optimisation. Elle décide ou non d'affectuer du padding sur les variables pour éviter des cache misses (défauts de cache). Les arguments sont :- arraypad : le compilateur va effectuer du padding (décalage à sa convenance) sur les tableaux pour lesquels un gain peut être obtenu. Tous les tableaux ne seront pas obligatoirement affectés et d'un tableau à l'autre, le décalage peut varier ;
- arraypad=n : le compilateur va effectuer du padding sur tous les tableaux du programme avec le même décalage. Il est alors souhaitable de prendre pour n un multiple de la plus grande taille d'éléments de tableau (6, 8 ou 16) ;
- vector et novector : le compilateur convertit certaines opérations effectuées dans une boucle sur des éléments consécutifs d'un tableau (racine carrée, ...) en un appel à une routine présente dans la librairie libxlopt.a. Cet appel va effectuer plusieurs calculs à la fois (chevauchement), ce qui est plus rapide que de les effectuer à la suite.
En mettant -qhot=novector, le compilateur effectue des transformations sur les boucles et les fonctions sur les tableaux mais ne fait pas les appels aux routines "vectorielles".
L'option -qhot=vector peut modifier la précision des résultats du programme de manière inacceptable, on peut alors mettre les options-qhot=novector ou -qstrict pour y remédier.
les deux arguments arraypad et arraypad=n doivent être utilisés avec précaution car il n'y a pas de vérification en cas de reshaping (fonction reshape) ou l'équivalence et un plantage du programme peut alors survenir. L'argument -qhot=vector est la sous-option par défaut lorsque l'on spécifie l'une des options : -qhot, -qsmp, -O4 ou -O5 (voir ci-dessous).
L'option par défaut est -qnohot.
Retour au début de la section .9. Option -qipa[=suboptions]
L'option -qipa renforce l'optimisation en effectuant une analyse détaillée entre les procédures (IPA : interprocedural analysis, soit analyse inter-procédurale).L'option -qipa nécessite la présence d'un niveau d'optimisation parmi -O, -O2, -O3, -O4 ou -O5. Pour une possible amélioration, on peut aussi spécifier l'option -Q (voir ci-dessus). L'option -qipa étend la portée de l'analyse durant les phases d'optimisation et d'inlining d'une seule procédure à de multiples procédures (même placées dans des fichiers différents) et l'édition des liens entre-elles.
L'utilisation de l'analyse interprocédurale se fait en deux étapes :- on effectue l'analyse de performance avant l'utilisation de l'option -qipa ;
- on spécifie l'option -qipa à la compilation et à l'édition des liens.
Durant la compilation, le compilateur stocke les informations de l'analyse interprocédurale dans le fichier objet, extension .o. Durant l'édition des liens l'option -qipa effectue une ré-optimisation complète de l'application (dans son intégralité) .
- inline=auto|noauto : spécifie ou pas l'inlining automatique ;
- inline=procedure-names : spécifie une liste de routines que l'éditeur de liens doit essayer d'inliner ;
- level=lev : spécifie le niveau de l'étude, 0 (analyse et optimisations minimales), 1 (activation de l'aliasing et étude limitée) et 2 (analyse interprocédurale complète) ; ce dernier est mis en place par le niveau d'optimisation -O5 ;
- list=[filename|short|long] : spécifie un nom de fichier (a.lst est le nom par défaut) pour le rapport d'analyse ainsi que l'importance du rapport ;
- noinline=procedure-names : spécifie une liste de routines qui ne doivent pas être inlinées.
- pdfname=filename : spécifie le nom du fichier d'informations pour le profile-directed feedback (pdf).
10. Options -qlargepage et -qnolargepage
L'option -qlargepage indique au compilateur que le programme compilé peut améliorer ses performances en utilisant les pages mémoire de 16 Mo (au lieu de 4 ko standard). Cette option peut être utile pour les programmes qui brassent un gros volume mémoire de données.L'option par défaut est -qnolargepage. Retour au début de la section .
11. Option -qpdf{1|2}
L'option -qpdf active les optimisations au travers du profile-directed feedback (pdf) qui permet d'améliorer les performances des programmes au voisinage des branchements en se basant sur le retour d'exécutions test.L'utilisation de l'analyse interprocédurale se fait en trois étapes :
- on compile les fichiers source souhaitées avec l'option -qpdf1 et un niveau d'optimisation minimal (-O3, -O4 voire -O5 plutôt que -O2) ;
- on exécute le programme avec un jeu de données représentatif. On peut effexctuer plusieurs exécutions consécutives, les informations sont accumulées ;
- on effectue la compilation des routines avec l'option -qpdf2 au lieu de -qpdf1. Il est important que toutes les autres options soient les mêmes pour les sous-programmes concernés. Dans cette seconde phase, les informations collectées sont employées pour affiner les optimisations.
il faut s'assurer que la variable d'environnement PDFDIR correspond à un chemin absolu sous peine d'échec de la procédure, c'est le répertoire courant si elle n'est pas initialisée.
Ces optimisations doivent avoir lieu après le déboguage et toutes les autres optimisations.
On peut utiliser l'option -qipa=pdfname=filename pour spécifier différents noms de fichier d'informations.
La première phase (-qpdf1) s'accompagne d'une légère dégradation des performances qui disparait lors de la troisième (-qpdf2). Retour au début de la section .
12. Options -qsmp et -qnosmp
L'option -qsmp indique que le code généré est produit pour un systè SMP ( Symmetric Multiprocessors).Avec cette option, le compilateur reconnait les directives SMP$, !$OMP et IBMP.
Il est important d'utiliser alors un compilateur qui soit thread safe, pour les phases de compilation et d'édition de liens, il s'agit de xlf_r, xlf90_r, xlf95_r.
L'option -qsmp dispose de plusieurs arguments :
- auto (défaut) | noauto : cette sous-option contrôle la parallélisation automatique (à éviter). Par défaut, le compilateur va essayer de paralléliser chaque boucle explicite DO ainsi que celles générées par le compilateur lorsqu'il traite les fonctions tableaux intrinsèques. L'argument noauto désactive la parallélisation automatique et seules les constructions qui sont explicitement signalées, sont parallélisées. La sous-option omp implique ce dernier argument.
- nested_par | nonested_par(défaut) : avec cette sous-option, le compilateur parallélise les boucles imbriquées (en fait il sérialise la boucle interne). Cet argument n'est pas conforme à l'API Fortran d'OpenMP.
- omp | noomp(défaut) : le compilateur traite le code en respectant l'API Fortran d'OpenMP. Cela implique : désactivation de la parallélisation automatique, la seule directive reconnue est !$OMP (on peut en ajouter d'autres avec l'option -qdirective).
- opt | noopt(défaut) : si l'option -qsmp=noopt est spécifiée, alors le compilateur va effectuer le travail d'optimisation minimal nécessaire pour paralléliser le code. C'est utile en phase de déboguage en complément de l'option -g.
- schedule =options : on peut définir la manière dont les itérations vont être partagées entre les différentes threads au sein des régions parallèeles. On a le choix entre :
- affinity[=n] : les itérations sont partagées en autant de partitions qu'il y a de threads, chacune d'elle étant initialement assignée à une thread avant d'être ensuite subdivisée en paquets de n ;
- dynamic[=n] : les itérations sont directement partagées en paquets de n itérations. L'attribution est faite en suivant la règle du "premier arrivé, premier servi" ;
- guided[=n] : les itérations sont distribuées en groupes de plus en plus petit jusqu'à atteindre n itérations ;
- runtime : le choix est fait à l'exécution, par exemple à l'aide d'une variable d'environnement ;
- static[=n] : les itérations sont partagées en groupe de n itérations, qui sont distribuées en "round robin" ;
- threshold =n : elle contrôle le niveau de parallélisation automatique qui a lieu, où n sert de "seuil" minimal pour effectuer ou non ce travail.
13. Options -qstrict et -qnostrict
L'option -qstrict vérifie que les optimisations effectuées par les options -qhot, -O3 et -qipa n'altèrent pas la sémantique des programmes Fortran90 et Fortran95.Elle est utile si l'augmentation du niveau d'optimisation entraine l'apparition de différences avec les résultats obtenus par des codes non optimisés. Ces différences peuvent avoir pour origine l'utilisation de l'associativité de la multiplication ou de l'addition, l'apparition et le traitement d'exceptions, ...
L'option par défaut est -qnostrict.
Retour au début de la section .14. Options -qstrictieeemod et -qnostrictieeemod
Ces options spécifient si le compilateur va suivre ou non les règles d'arithmétiques IEEE du Fortran 2000.L'option par défaut est -qnostrictieeemod.
Retour au début de la section .15. Option -qthreaded
Cette option indique au compilateur qu'il doit générer un code thread safe.Cette option est activée par défaut par les commandes xlf_r, xlf90_r et xlf95_r. Retour au début de la section .
16. Option -qtune=implementation
Cette option contrôle le choix des instructions, des améliorations de performance qui dépendent de l'architecture d'exécution. Cela concerne l'utilisation des caches, le pipelining des opérations, ce qui profite surtout aux programmes faisant beaucoup d'opérations en virgule flottante.Lorsque l'on optimise un code, il faut spécifier cette option avec l'attribut pwr4 pour les plateformes à base de processeurs Power4 ou auto pour avoir une compilation adaptée à chaque type d'architecture IBM.. Retour au début de la section .
17. Options -qunroll[=auto|yes] et -qnounroll
Ces options spécifient si le compilateur a le droit ou pas de dérouler les boucles DO (unrolling).Cela ne s'applique qu'aux boucles internes, i.e. celles qui ne contiennent aucune autre boucle. L'option -qunroll peut être dotée d'un argument parmi les deux suivants :
- auto : le compilateur effectue les opérations basiques d'unrolling. C'est le niveau par défaut si -qunroll n'est pas spécifiée dans la commande de compilation ;
- yes : le compilateur effectue une recherche approfondie pour dérouler les boucles. C'est le niveau par défaut si -qunroll est spécifiée.
La présence de cette option ne garantit pas l'unrolling des boucles ; en effet le compilateur cherche à déterminer si cela est profitable ou non au programme.
Il est parfois judicieux de dérouler les boucles externes pour plus d'efficacité. Ce travail n'est pas effectué par le compilateur, il doit être fait à la main.
La page des conseils pratique fournit quelques exemples.
L'option -qnounroll inhibe l'unrolling.
Retour au début de la section .18. Option -qfloat=options
Cette option contrôle le traitement de cas particuliers en arithmétique flottante.Elle possède un certain nombre d'arguments avec des valeurs par défaut qui sont :
noflint, fold, nohsflt, nohssngl, maf, nonans, norndsngl, norrm, norsqrt, et nostrictnmaf. Ils sont décrits ci-dessous :
- flint | noflint (défaut) : optimisation plus sûre que hsflt en arrondissant les valeurs double précision seulement quand elles sont stockées dans des zones mémoire simple précision (REAL(4), e.g.). Cet argument est activé par le niveau -O3 sauf si -qstrict est présent ;
- fold (défaut) | nofold : évaluation des expressions flottantes constantes lors de la compilation ;
- hsflt | nohsflt (défaut) : optimisation qui empêche certais arrondis pour les valeurs simples précision et remplace les divisions par des multiplications par l'inverse du dénominateur. Par orécaution, il est conseillé d'évitée pour des calculs en simple précision ;
- hssngl | nohssngl (défaut) : optimisation plus sûre que hsflt en arrondissant en simple précision les expressions seulement quand elles sont stockées dans des zones mémoire simple précision (REAL(4), e.g.) ;
- maf (défaut) | nomaf : calculs flottants plus performants dans le cas de multiplication / addition enchainées (MAF). L'ordre des opérations peut alors être différent, ce qui peut modifier les résultats (non respect possible de la norme IEEE) ;
- nans | nonans (défaut) : détection des opérations utilisant les NaNs (le "s" est obligatoire, ce sont des NaNs souhaités) et les NaNs peuvent alors être tracés durant l'exécution avec -qflttrap=invalid:enable ;
- rndsngl | norndsngl (défaut) : arrondi du résultat de chaque opération en simple précision (REAL(4), e.g.). Cela peut être utile dans le portage de programmes venant d'architecture basé sur le PowerPC ;
- rrm | norrm (défaut) : désactivation des optimisations qui nécessitent le mode d'arrondi "arrondi au plus proche". C'est utile si le programme contrôle le mode d'arrondi en cours d'exécution (non respect possible de la norme IEEE) ;
- rsqrt | norsqrt (défaut) : calcul plus performant de l'opération division par une racine carrée en la remplaçant par la multiplication par l'inverse de la racine carrée. Cet argument est activé par le niveau -O3 sauf si -qstrict est présent ;
- strictnmaf | nostrictnmaf (défaut) : désactivation des transformations qui introduisent des MAF négatives car elle ne préservent pas le signe de la valeur zéro. (MAF = Multiply and Add Fused : multiplication / addition enchainées). Pour un respect strict de la sémantique du programme il faut utiliser les deux options -qstrict et -qfloat=strictnmaf ;
19. Option -qieee={Near(défaut)|Minus|Plus|Zero}
Cette option contrôle le mode d'arrondi que le compilateur utilise lorsqu'il évalue les expressions flottantes constantes lors de la compilation. Le mode d'arrondi est un des arguments suivants :- Near (défaut) : arrondi au plus proche nombre représentable ;
- Minus : arrondi au plus proche nombre représentable en direction de moins l'infini ;
- Plus : arrondi au plus proche nombre représentable en direction de plus l'infini ;
- Zero : arrondi au plus proche nombre représentable en direction de zéro.
20. Options -qzerosize et -qnozerosize
Cette option améliore les performances des programmes en inhibant la vérification de la taille des chaines de caractères nulles et des tableaux vides. Ces éléments vides ne sont pas admis en Fortran77 et pour les programmes Fortran 90 et 95 qui ne les utilisent pas, l'ajout de l'option -qnozerosize peut améliorer les performances.L'option par défaut est -qnozerosize.
Retour au début de la section .21. Proposition d'options d'optimisation
On a le choix entre plusieurs niveaux d'optimisation qui influent plus ou moins fortement sur la précision des résultats numériques : le programme s'exécute plus vite mais on perd de la précision par rapport aux résultats de référence (obtenus sans optimisation). Il faut donc s'arrêter au "bon" niveau.On peut ainsi tester plusieurs configurations, proposées ci-dessous, par niveau croissant l'optimisation :
| 1. | -O2 | -qarch=auto -qtune=auto -qmaxmem=-1 | ||
| 2. | -O3 | -qstrict | -qarch=auto -qtune=auto | |
| 3. | -O3 | -qarch=auto -qtune=auto | ||
| 4. | -qhot | -O3 | -qarch=auto -qtune=auto | |
| 5. | -qhot | -O3 | -qipa | -qarch=auto -qtune=auto |
Ces propositions peuvent être complétées par les options pour le profilage ou le backfeeding, pour un contrôle plus fin de l'inlining ou pour le respect de la norme IEEE pour l'arithmétique flottante, etc ...
A performances équivalentes, il vaut mieux prendre le niveau inférieur qui est plus sûr.
Voir aussi la rubrique Exemples de fichiers de compilation
Des options pour l'édition des liens
L'édition des liens consiste à créer un fichier exécutable à partir des fichiers objets des différents sous-programmes, de librairies, etc ...
Sauf en présence de l'option -c, xlf appelle l'éditeur de liens standard ld et lui transmet les arguments de la séquence de compilation qui ne sont pas reconnus par lui-même.
- 1. Option -b64
- 2. Options -bmaxdata:bytes et -bmaxstack:bytes
- 3. Options -Ldir et -lkey
- 4. Option -brename:.name,.name_
- 5. Option -bloadname:name
- 6. Option -blpdata
- 7. Proposition d'options
1. Option -b64
Cette option indique au linker qu'il doit créer un exécutable travaillant avec un espace d'adressage sur 64 bits. Retour au début de la rubrique.2. Options -bmaxdata:bytes et -bmaxstack:bytes
Ces options spécifient l'espace maximal de mémoire attribué d'une part pour le tas (heap, les "données") et d'autre part pour la pile (stack, les "variables locales").
Sur les systèmes AIX, le heap peut prendre jusqu'à 8 segments de 256 Mo, soit 0x80000000 (en hexadécimal).
Sur les systèmes AIX, la stack peut occuper 1 segment de 256 Mo, soit 0x10000000 (en hexadécimal).
Attention !! :
si vous employez ces options pour faire l'édition de liens de programmes soumis à LoadLeveler, il faut que la demande en mémoire corresponde aux valeurs utilisées pour renseigner ces deux options.
De plus, elles ne doivent pas être employées pour des programmes compilés en 64 bits.
Retour au début de la rubrique.3. Options -Ldir et -lkey
Ces options permettent de préciser d'une part un chemin supplémentaire pour chercher une librairie et d'autre part le nom de la librairie (par défaut : libkey.a). Retour au début de la rubrique.4. Option -brename:.name,.name_
Cette option permet de modifier le nom de l'objet appelé lors de l'édition des liens. Cela est utile pour les sous-programmes qui ont ou non pas un "underscore" à la fin de leur nom ; par exemple -brename:.flush,.flush_.
Remarque :
un inconvénient non négligeable est la présence obligatoire d'au moins une occurrence à traiter si cette option est spécifiée. Dans le cas contraire une erreur survient qui provoque l'arrêt de l'édition de liens.
5. Option -bloadname:name
Cette option permet de sauvegarder dans le fichier de nom name un compte-rendu des actions de l'éditeur de liens. Retour au début de la rubrique.6. Option -blpdata
Cette option permet de demander des large pages mémoire (16 Mo au lieu de 4 ko) pour les applications qui brassent un gros volume mémoire de données. Elle permet de se limiter à refaire l'édition des liens plutôt que toute la compilation.Les large pages peuvent améliorer les performances des applications consommatrices de bande passante mémoire de l'ordre de 20 %.
Retour au début de la rubrique.
7. Proposition d'options pour
Une séquence basique d'options pour un programme en Fortran 77 pourrait être :
Voir aussi la rubrique Exemples de fichiers de compilation
Exemples de fichiers de compilation Makefile
Le passage du code source à l'exécutable se déroule en plusieurs étapes et dépend des options de compilation insérées dans le fichier de compilation Makefile. Il s'agit d'un fichier de description contenant des informations sur les dépendances entre les fichiers et les commandes à exécuter pour mettre à jour les cibles (targets) selon les modifications des fichiers dont elles dépendent. La compilation est lancée en tapant make target avec la cible voulue. Outre la manpage de b>make, ce fichier est un descriptif de la syntaxe propre au Makefile.
Les exemples donnés ci-dessous sont destinées à des programmes écrits en Fortran90.
Il faut noter que l'extension .f90 n'est pas initialement reconnue par les compilateurs IBM, cela explique la présence de la ligne .SUFFIXES:.f90 dans l'en-tête de ces fichiers.
Pour des programmes en Fortran77, il suffit d'effectuer les deux substitutions suivantes :
- xlf au lieu de xlf90;
- -qfixed=132 -qsuffix=f=f au lieu de -qfree=f90 -qsuffix=f=f90.
Chaque fichier Makefile contient des options conseillées pour le déboguage, pour l'optimisation, etc ...
Il est bien sûr possible de les compléter avec des options pour le profilage, le backfeeding, etc ...
1. Programme séquentiel
Il n'y a pas d'option spécifique. Fichier Makefile programme séquentiel2. Programme parallèle MPI
Le compilateur n'est plus xlf90 mais mpxlf90.Le préfixe mp signifie que le compilateur définit les chemins pour chercher les fichiers et bibliothèques spécifiques à MPI (Messages Passing Interface). Fichier Makefile programme parallèle MPI
3. Programme parallèle OpenMP
Le compilateur n'est plus xlf90 mais xlf90_r.L'extension _r signifie que le compilateur supporte les threads selon la norme POSIX qui sont par exemple employées pour la parallélisation par OpenMP et qu'il est aussi threadsafe . Fichier Makefile programme parallèle OpenMP Retour au début de la section.
Variables d'environnement courantes
1. Variables d'environnement compilateur XLF
Les options décrites dans cette section concernent la phase d'exécution, runtime, et s'articulent autour des variables XLFRTEOPTS et XLFSMPOPTS.Elles se présentent sous forme d'affectations (signe "=") et peuvent se succéder avec un double-point (":") pour les séparer. De plus elles ne sont pas sensibles aux majuscules / minuscules.
1.1 XLFRTEOPTS
La variable d'environnement XLFRTEOPTS permet de spécifier des options qui affectent les entrées / sorties, la gestion des erreurs sur les EOF, la spécification du générateur aléatoire, etc ...Elle est vérifiée lorsque le programme rencontre une des situations suivantes :
- l'exécution d'une lecture/écriture disque;
- un appel à la function RANDOM_SEED;
- la production d'un message d'erreur par les functions ALLOCATE et DEALLOCATE.
Pour modifier certaines options durant l'exécution d'un programme et pour qu'elles soient prises en compte par celui-ci, il faut insérer un appel à la function SETRTEOPTS dans le programme avec comme unique argument une chaine de caractères reprenant la syntaxe précédente. Seuls les options concernées par cet appel sont affectées. Les modifications sont effectives jusqu'à la fin du programme ou du prochain appel à la function SETRTEOPTS qui les concerne.
Pour les programmes Fortran90 utilisant les functions intrinsèques (MATMUL, SUM, ...), une seule variable doit être réellement initialisée, il s'agit de intrinthds. Sa valeur contrôle le nombre de threads créées à l'exécution de ses routines. Il est conseillé de la mettre à 1, par exemple en C-shell :
setenv XLFRTEOPTS "intrinthds=1"
1.2 XLFSMPOPTS
La variable d'environnement XLFSMPOPTS permet de spécifier des options qui affectent les exécutions de programmes parallèles reposant sur la mémoire partagée (SMP), comme les programmes utilisant les pthreads.Dans le cas de programmes OpenMP, ll vaut mieux laisser la gestion du partage des itérations (schedule) et du nombre de threads aux directives et functions OpenMP puisque ces dernières ont préséance sur XLFSMPOPTS et que cela reste totalement portable. Par défaut, chaque thread dispose d'une stack de 4 Mo, ce qui est souvent insuffisant. On peut donc l'augmenter avec XLFSMPOPTS de la manière suivante :
setenv XLFRTEOPTS "stack=67108864" : l'unité est l'octet et chaque thread peut alors prendre jusqu'à 64 Mo pour ses variables privées.
2. Variables d'environnement AIX
Les quelques variables suivantes ont un impact important sur la manière dont les threads se comportent dans les deux situations suivantes : fin du travail assigné, plus d'autres travaux. On peut décider de les mettre en attente active (busy-wait) ou en sommeil (sleep). Une séquence classique peut être définie en C-shell de la manière suivante :setenv YIELDLOOPTIME 1000000
setenv AIXTHREAD_MNRATIO 1:1
setenv SPINLOOPTIME 1000000
setenv AIXTHREAD_SCOPE S Ces initialisations sont faites par défaut aussi bien en interactif qu'en batch.
3. Variables d'environnement POE
Les variables affectant l'exécution de programmes parallèles MPI sont :- MP__PROCS : nombre de processus de l'application MPI en exécution interactive;
- MP_SHARED_MEMORY : à mettre à yes pour optimiser les communications;
- MP_EUILIB : à mettre à ip (pas d'exécution à cheval sur les noeuds);
- MP_WAIT_MODE : à mettre à poll en général; sauf dans le cas de programmes maitre / esclaves où le maitre ne fait strictement rien (mettre alors à sleep) ;
- MP_HOSTFILE : mettre le chemin vers le fichier host.list dans le cas d'exécution interactive.
Messages d'erreur du compilateur
Lorsque le compilateur rencontre un problème il génère un message d'erreurs. Cette page reprend les messages les plus couramment rencontrés qui nécessitent quelques explications.
- Compréhension des messages
- 1500-036 (I) The NOSTRICT option ...
- 1500-030 (I) specifying MAXMEM option ...
Compréhension des messages
Les messages générés par le compilateur ont un niveau de sévérité qui suit la règle suivante :- i (informational messages) : messages d'information. Ils expliquent des choses à savoir mais en général ils ne demandent pas de réaction en retour ;
- l (language-level messages) : messages liés au langage comme ceux produits par -qlanglvl . Ils indiquent des constructions potentiellement non portables;
- w (warning messages) : messages d'avertissement. Ils indiquent des possibilités d'erreur qui peuvent nécessiter une réaction, cependant le programme est encore correct ;
- e (error messages) : messages d'erreur. Ils indiquent des erreurs qui nécessitent une réaction pour que le programme soit correct mais le programme peut peut-être encore être exécuté;
- s (severe error messages) : messages d'erreur sévère. Ils indiquent des erreurs qui nécessitent une réaction pour que le programme soit correct et le programme plantera à l'exécution s'il atteint cet endroit;
- u (unrecoverable error messages) : message d'erreur irrécupérable. Ils indiquent des erreurs qui empêchent le programme de continuer. Elles nécessitent une action pour poursuivre la compilation.
L'option -qhalt (rubrique déboguage) permet d'interrompre la compilation en fournissant un niveau de halt_severity.
L'option -qflag (rubrique listing et messages) permet d'inhiber les messages d'erreur dont la sévérité est inférieure au niveau terminal_severity.
L'option -qsuppress:nnnn-mmm (rubrique listing et messages) permet d'inhiber la sortie de messages spécifiques.
| Numéro | Signification |
|---|---|
| 0 | le compilateur n'a pas rencontré de messages d'erreur dont la sévérité est suffisante pour interrompre le processus de compilation |
| 1 | le compilateur a rencontré un message de sévérité e ou halt_severity |
| 40 | erreur dans les options |
| 41 | erreur dans un fichier de configuration |
| 250 | erreur de dépassement de mémoire : le compilateur ne peut pas allouer toute la mémoire dont il a besoin |
| 251 | réception d'un signal : le compilateur a reçu un signal d'arrêt (ctrl-c par exemple) |
| 252 | erreur : fichier non trouvé |
| 253 | erreur d'entrée/sortie : le compilateur ne peut pas lire ou écrire des fichiers |
| 254 | erreur : le compilateur ne peut pas créer un nouveau processus |
| 255 | une erreur est survenue lors de l'exécution d'un processus |
| 15 | indique qu'il s'agit d'un message provenant de xlf | |
|---|---|---|
| cc | est le component number comme suit : | |
| 00 | indique un message de l'optimisation ou de la génération du code | |
| 01 | indique un message lié aux commons | |
| 11-20 | indique un message spécifique au Fortran | |
| 24 | indique un message du préprocesseur VAST-2 | |
| 25 | indique un message d'erreur d'une application du XL Fortran | |
| 26 | indique un message du préprocesseur KAP | |
| 85 | indique un message de la transformation des boucles | |
| 86 | indique un message de l'analyse interprocédurale | |
| nnn | est le numéro du message | |
| severity_letter | indique le degré de sévérité du problème, comme décrit ci-dessus | |
| 'message_text' | est le texte décrivant l'erreur | |
1500-036 (I) The NOSTRICT option (default at OPT(3)) has the potential to alter the semantics of a program
Séquence de compilation :
xlf90 -qsuffix=f=f90 -c -qhot -qarch=auto -qtune=auto -qhot -O3 pmm1.f90
** pmm1 === End of Compilation 1 ===
"pmm1.f90", 1500-036 (I) The NOSTRICT option (default at OPT(3)) has the potential to alter the semantics of a program. Please refer to documentation on the STRICT/NOSTRICT option for more information.
1501-510 Compilation successful for file pmm1.f90.
Le message est de type information (I) et peut survenir très souvent.
Il indique une possibilité d'altération des résultats numériques. Cela concerne le signe du nombre zéro, l'associativité des opérations, ...
Pour le faire disparaitre il suffit d'ajouter l'option -qstrict qui assure que les optimisations n'altèrent pas la sémantique des programmes.
1500-030 (I) INFORMATION: specifying MAXMEM option with a value greater than 2048
Séquence de compilation :
xlf90 -qsuffix=f=f90 -c -O2 pmm2.f90
** pmm2 === End of Compilation 1 ===
"pmm2.f90", 1500-030 (I) INFORMATION: pmm2: Additional optimization may be attained by recompiling and specifying MAXMEM option with a value greater than 2048.
1501-510 Compilation successful for file pmm2.f90.
Il indique que la mémoire disponible pour effectuer la compilation n'a pas permis d'effectuer toutes les optimisations. En effet, par défaut le compilateur ne dispose que de 2 Mo = 2048 ko.
Pour le faire disparaitre on a le choix entre :
- spécifier l'argument "-1" afin d'autoriser le compilateur à prendre toute la mémoire qu'il souhaite par -qmaxmem=-1;
- monter le niveau d'optimisation au moins au niveau O3 (si c'est possible), ce qui entraine aussi -qmaxmem=-1.
Messages d'erreur de l'éditeur de liens
Lorsque l'éditeur de liens rencontre un problème il génère un message d'erreurs. Cette page reprend les messages les plus couramment rencontrés qui nécessitent quelques explications.
ld: 0711-317 ERROR: Undefined symbol: .pmm2
Séquence de compilation :
xlf90 -qsuffix=f=f90 pmm1.o main.o -o f90.out
ld: 0711-317 ERROR: Undefined symbol: .pmm2
ld: 0711-344 See the loadmap file main for more information.
Pour avoir des informations complémentaire sur l'origine de ce symbole, on ajoute l'option -bloadmap avec le nom du symbole comme argument : xlf90 -qsuffix=f=f90 pmm1.o main.o -o f90.out -bloadmap:pmm2 La même erreur survient mais le fichier pmm2 est crée et son contenu est le suivant : ld: 0711-318 ERROR: Undefined symbols were found.
The following symbols are in error:
Symbol Inpndx TY CL Source-File(Object-File) OR Import-File{Shared-object}
RLD: Address Section Rld-type Referencing Symbol
----------------------------------------------------------------------------------------------
.pmm2 [61] ER PR test1.f90(test1.o)
00000794 .text R_RBR [12] .main
ER: The return code is 8. Cela indique que le symbole est référencé dans la routine qui s'appelle main. Retour au début de la section.