Ada : options principales des compilateurs Intel Fortran et C/C++

Nous ne détaillons ici qu'une partie des options proposées par les compilateurs Intel. Nous vous invitons à consulter les aides en ligne d' ifort et d' icc (commandes man ifort et man icc) pour des informations détaillées sur toutes les options disponibles.

Options d'optimisation des compilateurs Fortran et C/C++

C'est l'option -O (la lettre o majuscule) qui permet de gérer l'optimisation d'un code. Il est possible d'indiquer le niveau d'optimisation désiré en adjoignant une valeur entière (0, 1, 2 ou 3). L'option -O0 (tiret o majuscule zéro) permet d'inhiber toute optimisation faite par le compilateur. L'écriture -O (tiret o majuscule seul) est équivalente à -O2; c'est par ailleurs le niveau d'optimisation par défaut.

Attention : à partir du niveau 3, la sémantique du programme peut être modifiée. Par exemple : (2.*3.1)*4.2 peut être interprété comme 2.*(3.1*4.2). Soyez donc très vigilants quant aux résultats de vos calculs : il est nécessaire, à partir de-O3, de valider les résultats de vos modèles en les comparant avec une exécution réalisée avec une optimisation modérée ou, délibérément, sans aucune optimisation.

Options d'optimisation Commentaires
-O0 Aucune optimisation effectuée.
-O1 Quelques optimisations permettant d'accélérer modérément les calculs.
-O2 ou -O (défaut) Niveau d'optimisation incluant la vectorisation, l'inlining, le déroulement de boucle, l'optimisation inter-procédurale au sein de chaque fichier source, etc.
-O3 Optimisations plus agressives qu'en -O2 avec le prefetching, les transformations de boucle, la duplication de code, …
-O3 -xAVX Permet d'activer la vectorisation (instructions propres aux processeurs de type Sandy Bridge). Elle déclenche une analyse de la dépendance des données plus importante et peut donc accroître le temps de compilation.
Attention : le code ainsi compilé ne peut être exécuté sur les nœuds de pré/post-traitement car ils ont des processeurs de type Westmere.
-O3 -axAVX,SSE4.2 L'option -ax permet de générer un code dit architecture dépendant : le choix des instructions exécutées se fait alors en fonction de l'architecture utilisée. La combinaison d'options proposée permet ainsi d'obtenir un code optimisé à la fois pour Sandy Bridge (nœuds de calcul) et pour Westmere (nœuds de pré/post-traitement).

Il est possible que votre code ne donne pas les mêmes résultats en -O3 qu'en -O2. Vous pouvez alors obtenir un niveau d'optimisation intermédiaire en ajoutant l'option -fp-model suivie d'un mot clé (par exemple -O3 -fp-model precise).

Options d'optimisation Commentaires
-O3 -fp-model strict Les optimisations effectuées assurent la précision des calculs sur les nombres en virgule flottante (niveau le plus strict). De plus, la gestion des exceptions est activée.
-O3 -fp-model strict -fp-model no-except Comme précédemment, mais sans la gestion des exceptions.
-O3 -fp-model precise Assure la précision des calculs sur les nombres en virgule flottante. Il n'y a pas de gestion des exceptions.
-O3 -fp-model precise -fp-model except Comme précédemment, mais avec la gestion des exceptions.
-O3 -fp-model fast=1 ou -O3 -fp-model fast Autorise des optimisations plus agressives pouvant altérer la précision des calculs sur les nombres en virgule flottante. Peut donner de meilleures performances, mais ne peut pas être combinée avec la gestion des exceptions (-fp-model except).
-O3 -fp-model fast=2 Le code peut être encore plus rapide et moins précis qu'avec -fp-model fast=1. Ne peut pas être combinée avec la gestion des exceptions (-fp-model except).

Remarque : En l'état actuel, l'option -fast est équivalente aux options : -ipo -O3 -no-prec-div -xHost -static. Pour obtenir un exécutable, il est nécessaire d'enlever l'option -static. Aussi nous vous déconseillons de spécifier l'option -fast de façon isolée; utilisez plutôt l'ensemble des options listées ci-dessus.

Options mémoire pour les compilateurs Fortran et C/C++

Options mémoire Commentaires
-auto Les variables locales déclarées au sein d'une unité de programme sans l'attribut SAVE et non initialisées seront allouées à l'entrée de cette unité dans la pile d'exécution ou stack. Cette option permet alors de réduire la taille de l'exécutable (zones statiques DATA et BSS). Les variables locales doivent être valorisées explicitement sinon elles ont une valeur indéfinie (l'option ''-ftrapuv'' permet de détecter les variables non initialisées). L'option par défaut est -auto-scalar (seules les variables locales scalaires sont allouées dans le stack. L'option inverse est -save (toutes les variables locales héritent de l'attribut SAVE, elles sont allouées statiquement dans la zone BSS et initialisées implicitement à une valeur nulle).
-assume realloc_lhs Cette option permet d'activer le mécanisme d'auto-allocation mémoire introduit par la norme “F2003” lors d'opérations d'affectation portant sur des variables ayant l'attribut ALLOCATABLE : le plus souvent des tableaux. Attention : si ce mécanisme d'auto-allocation est utilisé sans le positionnement de cette option, les résultats sont imprévisibles. Peut induire un surcoût.
-mcmodel=small L'espace mémoire réservé au code (zone TXT) et aux données (zone DATA et BSS) est alors limité à 2Go. Cette valeur est suffisante dans la plupart des cas et le code présente alors les meilleures performances.
-mcmodel=medium -shared-intel Dans ce cas, seul l'espace mémoire réservé au code (zone TXT) est limité à 2Go; il n'y a aucune restriction pour les données. Les performances du code peuvent être légèrement dégradées. Cette option est nécessaire si vous avez des données statiques et globales (tableaux statiques p.ex.) dont la taille dépasse 2Go. Notez que vous devez aussi spécifier l'option -shared-intel.
-mcmodel=large -shared-intel Il n'y a alors aucune restriction concernant l'espace mémoire réservé au code ou aux données. Les performances du code peuvent être légèrement dégradées. Notez que vous devez aussi spécifier l'option -shared-intel.

Remarque : les options -mcmodel=medium -shared-intel doivent être ajoutées à la compilation et à l'édition de liens si vous obtenez des messages à l'édition de lien du type :

relocation truncated to fit: R_X86_64_PC32 against symbol ...

Ces messages peuvent apparaître lorsque l'on utilise des gros tableaux statiques, par exemple.

Options de diagnostic des compilateurs Fortran et C/C++

Des options permettent lors de la compilation, de récupérer certains messages de diagnostic sur la sortie standard ou dans un fichier :

Options de listage Commentaires
-openmp-report[=n] Génère, sur la sortie standard, un rapport des transformations faites pour un code OpenMP. n est optionnel et peut valoir 0, 1 ou 2 (par défaut =1). Plus n est grand, plus le rapport est détaillé. Naturellement, cette option n'est activée que si elle est accompagnée de l'option -openmp.
-opt-report [n] Génère, sur la sortie standard, un rapport des transformations liées à l'optimisation (inlining, vectorisation, déroulement de boucle, etc…). n est optionnel et peut valoir 0, 1, 2 ou 3 (par défaut 2) . Plus n est grand, plus le rapport est détaillé.
-opt-report-file=filename Génère un rapport dans le fichier spécifié par filename. Dans ce cas, il n'y a plus besoin de spécifier l'option -opt-report.
-opt-report-phase=phase -opt-report Combinaison de deux options permettant de générer un rapport des optimisations effectuées par l'élément phase de l'optimiseur. phase peut valoir :
ipo : Interprocedural Optimizer phase;
hlo : High Level Optimizer phase;
hpo : High Performance Optimizer phase;
ilo : Intermediate Language Scalar Optimizer phase;
pgo : Profile Guided Optimization phase;
all : All optimizer phases.
-par-report[n] -parallel Génère un rapport concernant l'auto-parallélisation du code; lorsque les boucles ne sont pas parallélisées, la raison pour laquelle la parallélisation n'est pas effectuée est indiquée (dépendance, …). n est optionnel et peut valoir 0, 1, 2 ou 3 (par défaut 1). Plus n est grand, plus le rapport est détaillé. Il ne faut pas oublier de spécifier l'option -parallel.
-vec-report[n] Génère, sur la sortie standard, un rapport concernant la vectorisation du code. Lorsque la vectorisation ne peut être faite, la raison pour laquelle elle n'est pas effectuée est indiquée (dépendance, etc.). n est optionnel et peut valoir 0, 1, 2, 3, 4 ou 5 (par défaut 1). Plus n est grand, plus le rapport est détaillé.

Exemples :

$ ifort -O3 -opt-report 3 prog.f90
$ ifort -O3 -opt-report-file=my_report_file prog.f90
$ ifort -O3 -par-report3 -parallel prog.f90
$ icc -O3 -opt-report 3 prog.f90
$ icc -O3 -opt-report-file=my_report_file prog.f90
$ icc -O3 -par-report3 -parallel prog.f90

Options de débogage des compilateurs Fortran et C/C++

Dans une phase de débogage, les options suivantes peuvent être utilisées avec le compilateur Fortran comme avec le compilateur C/C++. Nous vous invitons à consulter l'aide en ligne des compilateurs (commandes man ifort et man icc) pour obtenir de plus amples informations.

Options de débogage Commentaires
-g Génère la table des symboles (numéros de ligne, variables, …) qui pourra ensuite être exploitée par un débogueur. Cette option conserve le niveau d'optimisation explcitement demandé (-O1, -O2 ou -O3). Sans niveau d'optimisation spécifié explicitement, cette option désactive toute optimisation (-g est équivalent à -g -O0).
-debug ou -debug full ou -debug all Génèrent des informations complètes de debug. Recommandées lorsque l'on combine -g avec un niveau d'optimisation spécifique (-O1, -O2 ou -O3) : par exemple -g -O2 -debug.
-traceback Permet d'obtenir plus d'information lorsqu'une erreur se produit à l'exécution. Cette option est aussi positionnée avec -g.
-ftrapuv Initialise les variables locales dans la stack à des valeurs aberrantes (entier très grand, adresse invalide). Ceci permet de détecter les variables non initialisées en provoquant une erreur à l'exécution. Notez qu'elle positionne aussi l'option -g.
-check uninit (Fortran) -check=uninit (C) Permet de détecter à l'exécution si les variables scalaires de type intrinsèque (integer, real, complex ou logical) et sans attribut SAVE ne sont pas initialisées.
-fp-stack-check Permet de générer une exception dès qu'un appel de fonction retourne une valeur incorrecte.
-no-ftz L'option -ftz est positionnée par défaut avec les optimisations -O1, -O2 et -O3; elle met à zéro les nombres dé-normalisés très petits durant l'exécution, ce qui peut produire des résultats erronés. Il est possible de désactiver cette fonctionnalité en ajoutant l'option -no-ftz afin de détecter ces underflows.

Options de débogage du compilateur Fortran

Avec le compilateur Fortran, vous pouvez aussi utiliser les options suivantes :

Options de débogage Commentaires
-debug-parameters all Génère des informations de debug pour les variables de type PARAMETER. Ceci est nécessaire pour voir les valeurs des PARAMETER avec un debugueur.
-heap-arrays Place tous les tableaux temporaires ou automatiques dans le heap au lieu de la stack si cette dernière se révèle trop petite.
-fpe-all=0 -no-ftz -traceback Cette combinaison d'options stoppe l'exécution dès qu'une exception (overflow, underflow, division par zéro, opération invalide,…) se produit; elle indique à quel niveau du code elle s'est produite. Le contrôle s'opère dans chaque subroutine, contrairement à l'option -fpe0 qui agit uniquement sur le programme principal.
-check bounds Détecte à la compilation et à l'exécution si un tableau est adressé en dehors de ses bornes (bound checking).
-check pointers Détecte à l'exécution si un pointeur est initialisé ou non, si un tableau allocatable est alloué ou non lors de l'utilisation des pointeurs.
-check all Permet de réaliser divers checks simultanément (notamment ceux listés ci-dessus).
-warn declarations Génère les messages signalant toutes les variables non déclarées (comme si le source comportait un IMPLICIT NONE).
-warn interfaces Génère les messages signalant les incohérences entre les appels et les définitions de chaque sous-routine et chaque fonction du code. Notez que le compilateur génère un bloc d'interface pour chacune d'entre elles (option -gen-interfaces implicite).
-warn truncated_source Pour les fichiers au format fixe, le compilateur émettra un message si une ligne du source dépasse la longueur maximale autorisée (défaut : 72 caractères). Notez que cette longueur peut être portée à 132 caractères maximum avec l'option-extend_source.
-warn all ou -warn Génère les divers messages d'avertissement simultanément (notamment ceux cités ci-dessus).
-stand f08 Des avertissements sont générés si la norme Fortran 2008 n'est pas respectée.

Options de débogage du compilateur C/C++

Avec le compilateur C/C++, vous pouvez aussi utiliser l'option suivante :

Options de débogage Commentaires
-check-pointers=rw Permet de détecter à l'​exécution les accès mémoire invalides lors de l'utilisation de pointeurs (cela inclut l'utilisation des tableaux, qu'ils aient été alloués dynamiquement ou non).

Exemples :

$ ifort -g -debug -fpe-all=0 -no-ftz -traceback -fp-stack-check -check all -warn all -stand f08 my_prog.f90
$ icc -g -debug -no-ftz -traceback -fp-stack-check -check=uninit -check-pointers=rw my_prog.c

Voir aussi la page : Outils de débogage.

Liste des options activées pour le compilateur Fortran

  • La liste des options actives par défaut peut évoluer dans le temps, mais aussi en fonction du contexte d'appel du compilateur. Il est possible de générer un listing de la compilation d'un fichier source en utilisant l'option -list : ifort -list prog.f90. Cette commande crée le fichier prog.lst dans le même répertoire que le fichier source. Par défaut, il contient :
    • le contenu des fichiers inclus via l'instruction include,
    • la liste des symboles pour chaque subroutine,
    • la liste des options de compilation.
  • L'option -show mot-clef permet restreindre l'action de l'option -list :
    • -show noinclude supprime le contenu des fichiers inclus via l'instruction include,
    • -show nomap supprime la liste des symboles pour chaque subroutine,
    • -show nooptions supprime la liste des options de compilation.

Taille des différents types de base Fortran

Les variables déclarées à l'aide des types par défaut INTEGER, REAL ou COMPLEX font l'objet d'une réservation en mémoire basée sur des mots de 4 octets. Le paramètre optionnel KIND=n indiqué à la suite du type permet d'influer sur cette taille ; c'est la façon la plus explicite et la plus sûre de le faire.

Il existe par ailleurs des options de compilation permettant de modifier de façon globale la longueur des variables, mais nous déconseillons formellement leur utilisation pour des raisons de portabilité :

  • les options équivalentes ne fonctionnent pas de la même façon sur des plateformes différentes,
  • il est très facile d'oublier ces options lorsqu'on compile son code ou qu'on le partage avec quelqu'un d'autre; dans ce cas les résultats de l'exécution sont faux !

Afin de permettre quelques tests ponctuels, ces options sont les suivantes :

  • -integer-size 16/32/64 force la réservation en mémoire des entiers et logiques déclarés avec le type INTEGER ou LOGICAL (sans spécification du paramètre KIND=n) sur des mots de 2/4/8 octets (4 par défaut);
  • -real-size 32/64/128 : les entités déclarées avec le type REAL ou COMPLEX (sans spécification du paramètre KIND) sont promues respectivement sur 4, 8 et 16 octets.

Lire ou écrire un fichier binaire Fortran IEEE big-endian

Ada est une machine Linux : par défaut, elle génère donc des fichiers binaires Fortran au format little-endian. Pour écrire ou lire un fichier binaire Fortran IEEE big-endian, il faut utiliser la variable d'environnement F_UFMTENDIAN. Pour lire un fichier binaire Fortran écrit en big-endian (provenant par exemple de notre ancienne IBM Power6 Vargas) sur l'unité 12 :

$ ifort -o prog_big_endian prog_big_endian.f90
$ export F_UFMTENDIAN=''big:12''
$ ./prog_big_endian

Remarque : Si vous ne spécifiez pas de numéro d'unité logique, alors la variable opère sur toutes les unités. Par conséquent tous les fichiers sont considérés comme ayant le même format (big-endian comme sur Power6 dans cet exemple) :

$ ifort -o prog_big_endian prog_big_endian.f90
$ export F_UFMTENDIAN=''big''
$ ./prog_big_endian

Il est possible de spécifier plusieurs unités logiques; ici, les unités 12, 15 et toutes celles de 20 à 30 :

$ export F_UFMTENDIAN=''big:12,15,20-30''
$ ./prog_big_endian

Attention : sur Ada, dans le cas d'un fichier à accès direct, la taille de l'enregistrement par défaut spécifié avec RECL est en mot (de 4 octets). Pour spécifier cette taille d'enregistrement directement en octets, il faut compiler avec l'option -assume byterecl.

$ ifort -assume byterecl -o prog_big_endian prog_big_endian.f90
$ export F_UFMTENDIAN=''big:12''
$ ./prog_big_endian