Options des compilateurs Intel (Fortran, C/C++)

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

Options d'optimisation

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 votre modèle en les comparant avec une exécution réalisée avec une optimisation modérée ou sans aucune optimisation.

Options d'optimisation	Commentaires
-O0	Aucune optimisation effectuée.
-O1	Quelques optimisations permettent 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 -xHost	Permet d'activer la vectorisation AVX2 et partiellement AVX512. Elle déclenche une analyse plus exhaustive des dépendances de données et peut accroître le temps de compilation.
-O3 -xHost -qopt-zmm-usage=high	Permet d'activer totalement la vectorisation AVX512. Elle déclenche une analyse plus exhaustive des dépendances de données et peut accroître le temps de compilation.

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. Comme nous vous déconseillons de spécifier l'option -fast de façon isolée, utilisez plutôt : -ipo -O3 -no-prec-div -xHost.

Options mémoire

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 (stack). Cette option réduit 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). Par défaut, -auto-scalar est activé (seules les variables locales scalaires sont allouées dans le stack). L'option inverse est -save, où toutes les variables locales héritent de l'attribut SAVE et sont allouées statiquement dans la zone BSS et initialisées à une valeur nulle.
-mcmodel=small	L'espace mémoire réservé au code (zone TXT) et aux données (zones DATA et BSS) est limité à 2 Go. Cette valeur est suffisante dans la plupart des cas et garantit les meilleures performances.
-mcmodel=medium -shared-intel	Seul l'espace mémoire réservé au code (zone TXT) est limité à 2 Go, sans restriction pour les données. Les performances peuvent être légèrement dégradées. Cette option est nécessaire si vous utilisez des données statiques et globales (comme des tableaux statiques) dont la taille dépasse 2 Go. Notez que l'option -shared-intel doit aussi être spécifiée.
-mcmodel=large -shared-intel	Il n'y a aucune restriction sur l'espace mémoire réservé au code ou aux données. Les performances peuvent être légèrement dégradées. Notez que l'option -shared-intel doit aussi être spécifiée.

remarque

Les options -mcmodel=medium -shared-intel doivent être ajoutées à la compilation et à l'édition de liens sinon vous obtiendrez des messages 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

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

Option de listage	Commentaires
-qopt-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'est plus nécessaire de spécifier l'option -qopt-report.
-qopt-report-phase=phase -qopt-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; openmp : OpenMP; par : Auto-parallélisation; vec : Vectorisation; all : All optimizer phases.

Exemples :

ifort -O3 -qopt-report=3 prog.f90

ifort -O3 -qopt-report-file=my_report_file prog.f90

ifort -O3 -qopt-report=3 -qopt-report-phase=par -parallel prog.f90

icc -O3 -qopt-report=3 prog.c

icc -O3 -qopt-report-file=my_report_file prog.c

icc -O3 -qopt-report=3 -qopt-report-phase=par -parallel prog.c

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 des compilateurs sur Jean Zay (commandes man ifort et man icc) pour obtenir de plus amples informations.

Option de débogage	Commentaires
-g	Génère la table des symboles (numéros de ligne, variables, ...). Cette table peut être exploitée par un débogueur. Cette option conserve le niveau d'optimisation explicitement demandé (-O1, -O2 ou -O3). Sans optimisation spécifiée explicitement, toute optimisation est désactivée (-g équivaut à -g -O0).
-debug ou -debug full ou -debug all	Génèrent les informations complètes de débogage. Recommandées avec -g et un niveau d'optimisation spécifique (-O1, -O2 ou -O3). Par exemple : -g -O2 -debug.
-traceback	Permet d'obtenir plus d'informations lorsqu'une erreur se produit à l'exécution. Cette option est aussi positionnée avec -g.
-ftrapuv	Initialise les variables locales dans la stack avec des valeurs aberrantes (entier très grand, adresse invalide). Permet de détecter les variables non initialisées en provoquant une erreur à l'exécution. Positionne également l'option -g.
-check uninit (Fortran) -check=uninit (C)	Détecte à l'exécution si des variables scalaires de type intrinsèque (integer, real, complex, 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 activé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. L'option -no-ftz permet de désactiver cette fonctionnalité et de détecter ces underflows.

Options de débogage du compilateur Fortran

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

Option 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 débogueur.
-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.
-init=arrays,snan	Force à NaN toutes les variables de type intrinsèque ainsi que les tableaux non initialisés. Cette option implique -fpe0. Pour éviter de récupérer des exceptions qui ne soient pas relatives à des variables non-initialisées, il est recommandé de réduire le niveau d'optimisation à -O1 ou -O0. Alternativement, vous pouvez utiliser -fp-speculation=safe pour la détection de variables non-initialisées.
-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, etc.) se produit. Elle indique à quel niveau du code elle s'est produite. Le contrôle s'effectue 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	Active les deux options listées ci-dessus simultanément.
-warn declarations	Génère les messages signalant toutes les variables non déclarées (comme si le code 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èrent 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 :

Option 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

Liste des options activées pour le compilateur Fortran

La liste des options activées par défaut par le compilateur Intel peut évoluer dans le temps, mais aussi en fonction du contexte d'appel du compilateur. Ainsi, il est possible qu'avec des versions différentes une compilation que vous lanciez sur un même code avec les mêmes options génère un exécutable qui ne donne pas exactement les mêmes résultats. Il est donc utile 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 sous-routine,
• la liste des options de compilation.

L'option -show mot-clef permet de 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 sous-routine,
• -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 dans le code source 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=n) sont promues respectivement sur 4, 8 et 16 octets.

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

Jean Zay 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 IEEE big-endian en Fortran, il faut utiliser la variable d'environnement F_UFMTENDIAN.
Pour lire un fichier binaire é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 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

Dans le cas d'un fichier à accès direct, la taille de l'enregistrement, indiqué lors de l'OPEN du fichier dans le code source au moyen du mot-clef RECL, est interprété en mots de 4 octets. Pour spécifier cette taille d'enregistrement directement en octets lors de l'OPEN, 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