Compilation, make

Compilation, make
École normale supérieure
L3 sciences de la planète
2016/2017
Lionel GUEZ
[email protected]
Laboratoire de météorologie dynamique
Langages interprétés versus
langages compilés (1/2)
programme
Python
(texte lisible)
exécution
interpréteur
Python
résultats
données
programme
Fortran
(texte lisible)
compilation
compilateur
Fortran
programme
machine,
fichier
exécutable
exécution
système
d'exploitation
résultats
données
2/27
Langages interprétés versus
langages compilés (2/2)

Interprétés : Python, Bash…

Compilés : Fortran, C, C++…

Un programme en langage compilé donne en
principe un exécutable plus rapide qu'un
programme équivalent en langage interprété.
3/27
Cas élémentaire



Un seul fichier à compiler
Noms à choisir pour le
fichier et le programme
principal
Nom de fichier pour
programme en Fortran,
convention : suffixe .f
(pas d'espace, de
caractères accentués,
etc. dans le nom)
1
fichier
1
programme
principal
Conseil :
my_program.f
program my_program
...
4/27
Fichier source et exécutable


Texte du programme en Fortran : ”fichier
source”
Compilation : traduction du Fortran en ”langage
machine”, langage du processeur
→ création d'un fichier ”exécutable”
5/27
make

Utilitaire UNIX (comme ls, cd, awk...)

Vocation première : aide à la compilation
–
Stockage dans un fichier, appelé GNUmakefile, de
toutes les informations nécessaires à la compilation
d'un programme, sous une forme directement
utilisable
–
Remarque : make n'est pas spécifique au Fortran, il
est conçu pour tous les langages compilés
6/27
Variables reconnues par make


FC : initiales de Fortran compiler, nom du
compilateur (à utiliser dans la commande de
compilation)
Exemple :
FC = gfortran
FFLAGS : Fortran flags, options de compilation
Exemple :
FFLAGS = -ffree-form -std=f95 -Wall
-fbounds-check …
Nota bene : -ffree-form : option format libre
7/27
Digression : format fixe ou libre



Format fixe du fichier source : façon d'écrire les
anciens programmes en Fortran (en Fortran 77
et avant). Instructions entre les colonnes 7 et
72, et autres règles de formattage.
Format libre du fichier source : introduit par
Fortran 90
Possibilité de dire le format fixe ou libre au
compilateur par une ”option du compilateur”.
8/27
Commande de compilation


make sait fabriquer l'exécutable plouf à partir
du fichier plouf.f.
On écrit seulement :
make plouf
(sans suffixe) qui signifie ”fabrique l'exécutable
plouf”

plouf.f et GNUmakefile doivent exister
dans le répertoire courant
plouf.f
source
make plouf
plouf
exécutable
9/27
Recette



Définir FC dans son environnement
(.profile)
Écrire seulement dans un fichier appelé
GNUmakefile la ligne :
FFLAGS = …
Utiliser ce GNUmakefile pour tous les
programmes à un seul fichier .f :
make plouf
make currency_2
make fibonacci
10/27
Commande d'exécution



chemin/plouf
Exemple :
~/Documents/plouf
Le répertoire courant, où l'exécution est lancée,
n'est donc pas forcément le répertoire où se
trouve le fichier exécutable.
Chemin = . pour le répertoire courant :
./plouf
11/27
make et les dates de modification


make ne compile que le nécessaire à partir des
dates de modification.
Donc si on refait make sans avoir modifié le
fichier source :
make plouf
On obtient le message :
make: `plouf' is up to date.
12/27
Importance des options de
compilation

Ne pas rater le meilleur du compilateur :
–
débogage
–
rapidité du programme

Deux fonctionnalités opposées : il faut choisir

Deux situations :
–
au début : mise au point sur de petits cas options
de débogage
–
pour produire des résultats options de rapidité
13/27
Options de débogage (1/2)


Pour signaler des instructions licites mais
parfois involontaires : conversion de type,
troncature d'une chaîne de caractères, calcul
donnant une valeur trop proche de 0, ligne
jamais exécutée
Pour détecter des erreurs : opération illicite sur
des réels (division par zéro, racine carrée d'un
nombre négatif, etc.), référence à un indice de
tableau hors limites, utilisation d'une variable
qui n'a pas reçu de valeur
14/27
Options de débogage (2/2)

Pour signaler un mauvais style de
programmation : un archaïsme du langage, une
extension du langage (peut-être pas acceptée
par tous les compilateurs)
15/27
Beaucoup d'options de débogage

Exemple pour gfortran :
-std=f95 -pedantic-errors -Wall
-Wconversion -Wimplicit-interface
-Wunderflow -Wextra -Wunreachable-code
-ffpetrap=invalid,zero,overflow,underflow -g3
-fbounds-check -O0 -fstack-protector-all

man gfortran pour la liste des options
(débogage et autres) avec explications
16/27
Des options de débogage qui
varient



En gros mêmes fonctionnalités de débogage
d'un compilateur à l'autre mais des options (ce
qu'il y a à écrire sur la ligne de commande) qui
changent beaucoup
Les options varient un peu dans le temps, pour
un compilateur donné, avec les versions du
compilateur.
Conseil : avoir une liste pour chaque
compilateur et la mettre à jour de temps en
temps (changements de version importants,
moins d'une fois par an)
17/27
Programme à deux fichiers
2
fichiers
1
programme
principal
1
module
1
procédure
18/27
Noms de fichiers et
identificateurs Fortran


Des noms à choisir pour : fichiers, programme
principal, module, procédure
Conseil : choisir une convention simple pour
que les correspondances soient évidentes
my_program.f
program my_program
use foo_m, only: foo
...
foo.f
module foo_m
...
contains
[subroutine | function] foo
...
19/27
Recette (1/2)


Le GNUmakefile va maintenant être spécifique
au programme.  Créer un répertoire
spécifique pour ce programme et y placer
GNUmakefile.
Ajouter dans GNUmakefile la ligne :
my_program: foo.o
(ligne ”de dépendance”).
20/27
Recette (2/2)

Dans le terminal, aller dans le répertoire du
programme et taper la commande :
make
tout court pour créer l'exécutable (ce qui doit
être créé, my_program, est maintenant écrit
dans le GNUmakefile, inutile de l'écrire sur la
ligne de commande).
21/27
Fichiers créés (1/2)
my_program.f
foo.f
GNUmakefile


make
foo.o
fichier
objet
foo_m.mod
my_program
exécutable
Un ”fichier objet”, en langage machine, non
exécutable, suffixe .o
Un fichier ”.mod”
foo_m.mod si le module s'appelle foo_m (le
nom du fichier .mod n'est pas formé à partir du
nom du fichier .f)
22/27
Fichiers créés (2/2)

Un fichier exécutable
nom de l'exécutable = nom du fichier
contenant le programme principal sans .f
23/27
GNUmakefile pour un programme
à 3 fichiers ou plus (1/3)

Écrire que l'exécutable dépend de tous les
objets (autres que l'objet correspondant au
programme principal). Exemple :
my_program: foo.o bar.o plouf.o
24/27
GNUmakefile pour un programme
à 3 fichiers ou plus (2/3)

Écrire les dépendances entre les objets (autres
que l'objet correspondant au programme
principal). Il y a dépendance s'il y a une
déclaration use. Par exemple, on écrit dans le
GNUmakefile :
foo.o: bar.o
s'il y a :
use bar
dans la procédure foo.
25/27
GNUmakefile pour un programme
à 3 fichiers ou plus (3/3)

Attention : la ligne de dépendance du
programme principal doit être avant les lignes
de dépendances entre les objets
26/27
Résumé : fichiers GNUmakefile
de complexité croissante
pour 1 fichier .f
FFLAGS = …
LDLIBS = …
GNUmakefile :
pour 2 fichiers .f
pour ≥ 3 fichiers .f
FFLAGS = …
LDLIBS = …
FFLAGS = …
LDLIBS = …
my_program: foo.o
my_program: foo.o bar.o …
foo.o: bar.o …
…
commande :
make my_program
make
make
27/27