Travail pratique #2 IFT-2030 November 7, 2005

(1)

Travail pratique #2

IFT-2030 November 7, 2005

¡¡ Dˆ u le 21 novembre ` a midi puis le 30 novembre ` a 8h30 !!

1 Survol

Ce TP a pour but de vous familiariser avec le langage C, les pointeurs, la gestion de m´emoire explicite.

Comme pour le TP précédent, les étapes sont les suivantes:

1. Parfaire sa connaissance de C.

2. Lire et comprendre cette donn´ee.

3. Lire, trouver, et comprendre les parties importantes du code fourni.

4. Compl´eter le code fourni.

5. Écrire un rapport. Il doit décrire votre expérience pendant les 4 points précédents: problèmes rencontrés, surprises, choix que vous avez dû faire, options que vous avez sciemment rejetées, etc... Le rapport ne doit pas excéder 5 pages.

Comme pour le TP1, les 3 premiers points occuperont probablement une large part du temps total.

Ce travail est à faire en groupes de 2 étudiants. Le rapport (au format PDF ou Postscript) et le code sont à remettre par remise électronique avant la date indiquée. Aucun retard ne sera accepté. Indiquez clairement votre nom au début de chaque fichier.

Si un étudiant préfère travailler seul, libre à lui, mais l’évaluation de son travail n’en tiendra pas compte. Si un étudiant ne trouve pas de partenaire, il doit me contacter au plus tard lundi 14 décembreavantle cours. Des groupes de 3 ou plus sontexclus.

La remise est `a faire en 2 temps. Le 21 novembre, vous devez remettre la solution de la premi`ere partie du travail (i.e. exp free), et le 30 novembre vous devez remettre la version finale et le rapport.

(2)

2 Une sorte de ML

Vous allez compl´eter une partie d’un compilateur d’un langage inspir´e de ML et Haskell. Ce langageµMLcomprend des expressions de la forme suivante:

e ::=n Un entier sign´e en d´ecimal

|”. . .” Une chaˆıne de caract`eres

|x Une variable

|(e) Parenth`eses

|(e:τ) Annotation de type

|(e1, e2) Une paire

|#1e|#2e Acc`es aux champs d’une paire

|e₁+e₂|e₁−e₂ |e₁∗e₂ |e₁/ e₂ Arithm´etique infixe

|fnargs⇒e Fonction anoynyme

|e₁e₂ Appel de fonction

|ife₁ thene₂ elsee₃ Expression conditionelle

|letdeclsine D´efinitions locales de variables et fonctions decls ::=decl{ ; decl}

decl ::=x[ : τ ] =e D´efinition de variable

|f args[ : τ ] =e D´efinition de fonction args ::= (x1:τ1). . .(xn:τn) Liste d’arguments

τ ::=int Le type des expressions enti`eres

|string Le type des chaˆınes de caract`eres

|τ1∗τ2 Le type des paires

|τ1→τ2 Le type des fonctions

La précédence des opérations arithmétiques et habituelle, l’appel de fonction est associatif à gauche et a la même précédence que l’accès aux champs d’une paire, et cette précédence est plus élevée que celle des opérateurs infixes (i.e. comme en Haskell).

Une partie importante de la syntaxe ci-dessus n’est que du sucre syntaxique.

Par exemple, les fonctions n’ont en réalité qu’un seul argument: la syntaxe offre la possibilité de déclarer plusieurs arguments, mais ce n’est que du sucre syntaxique pour des définitions en formecurried. Plus précisément, les equivalences suivantes sont vraies:

letx:τ=e₁ ine₂ ⇐⇒ letx= (e₁:τ)in e₂ letf args : τ=e₁ ine₂ ⇐⇒ letf args= (e₁:τ)in e₂

letf args=e₁ ine₂ ⇐⇒ letf =fnargs⇒e₁ ine₂ fnarg args⇒e ⇐⇒ fn arg⇒fnargs⇒e

Dans l’ensemble c’est un langage similaire à celui du TP1, mais avec une syntaxe différente et avec des annotations de type. Le let autorise aussi la récursion mutuelle.

La sémantique statique est standard, et elle est décrite formellement dans la figure 1. L’environnement de type Γ est une liste associative qui associe à chaque

(3)

Γ ` n : int

Γ(x) =τ Γ ` x : τ

Γ ` e : τ Γ ` (e:τ) : τ Γ ` e1 : τ1 Γ ` e2 : τ2

Γ ` (e₁, e₂) : τ₁∗τ₂

Γ ` e : τ1∗τ2

Γ ` #1e : τ₁

Γ ` e : τ1∗τ2

Γ ` #2e : τ₂ Γ ` e₁ : int Γ ` e₂ : int

Γ ` e1(+| − | ∗ |/)e2 : int Γ, x:τ1 ` e : τ2

Γ ` fn (x:τ1)⇒e : τ1→τ2

Γ ` e1 : τ1→τ2 Γ ` e2 : τ1

Γ ` e1 e2 : τ2

Γ ` e1 : int Γ ` e2 : τ Γ ` e3 : τ Γ ` if e₁then e₂elsee₃ : τ

Γ, x1:τ1, ..., xn:τn ` ei : τi Γ, x1:τ1, ..., xn:τn ` e : τ Γ ` letx₁=e₁;...;x_n=e_n ine : τ

Figure 1: R`egles de typage deµML

variable son type. La notation Γ, x:τ représente un nouvel environnement qui est semblable à Γ sauf qu’il associe à xle typeτ. La notation Γ(x) =τ signifie que x est associé à τ dans Γ. Le jugement noté Γ ` e : τ signifie que l’expression e a un type τ lorsqu’elle est dans un environnement statique Γ.

Finalement chaque règle de typage est notée _conclusion^pr´êmisses et signifie que si hacune des prémisses sont vérifiées, alors la conclusion est aussi vérifiée. Par exemple, la dernière règle indique que le type d’une expression let, est le type de sa sous-expressione. Elle indique aussi que cette sous-expressionedoit être typée dans un environnement statique où lesx_i est lié au type dee_i. Finalement elle indique aussi que lese_i sont aussi typés dans un environnement qui est étendu avec des liens pourx1...xn, ce qui reflète justement le fait que celetautorise les définitions récursives et que donc la portée de xi inclut non seulement emais aussi lesei.

Ceci dit, le code fourni s’occupe déjà de vérifier les types, donc vous n’avez pas à vous en préoccuper.

Vu que le langage est typé statiquement, il utilise nécessairement la portée statique. De plus, quoique cela n’influence pas votre travail, vous pouvez présumer que les paramètres sont passés par valeur.

3 Le code fourni

Le code fourni se r´eparti en plusieurs fichiers:

• alist.cetalist.h: un module tr`es simple de listes associatives simple-

(4)

ment chaˆın´ee.

• hash.cet hash.h: un module de tables de hachage.

• type.c et type.h: un module qui d´efini des types et des fonctions pour construire et manipuler les typesτ.

• exp.c et exp.h: un module qui d´efini des types et des fonctions pour construire et manipuler des expressionse.

• lex.l et parse.y: l’analyseur lexical et l’analyseur syntaxique, d´efinis avec l’aide des outilslexetyacc.

• uml.c: la fonction principale du programme qui lit les fichiers passés en paramètre, les analyses, vérifie leur type, et finalement les ré-imprime avec le résultat de la vérification de type.

• Makefile: les r`egles de compilation pourmake.

Voilà un exemple de session où j’ai extrait les fichiers fournis, j’ai compilé le programme, et je l’ai utilisé sur un test trivial. L’exécutable généré s’appelle uml:

% tar zxpf tp3.tar.gz

% cd tp3

% make

lex -olex.c lex.l

yacc -v -d -o parse.c parse.y yacc: 10 reduce/reduce conflicts.

cc -Wall -g -c -o lex.o lex.c

lex.c:1115: warning: ‘yyunput’ defined but not used cc -Wall -g -c -o parse.o parse.c

cc -Wall -g -c -o exp.o exp.c cc -Wall -g -c -o uml.o uml.c cc -Wall -g -c -o type.o type.c cc -Wall -g -c -o hash.o hash.c cc -Wall -g -c -o alist.o alist.c

cc -Wall -g -o uml lex.o parse.o exp.o uml.o type.o hash.o alist.o

% echo "1;" | ./uml Type error: 1

%

L’analyseur syntaxique élimine tout le sucre syntaxique pour vous, et génère un arbre de syntaxe abstraite. Cet arbre de syntaxe abstraite est défini dans le fichier principal exp.c. Une partie importante d’un ASA est comment sont représentés les identificateurs. Dans notre cas, les identificatuers sont simplement représentés par des chaˆınes de caractères, mais la comparaison entre identificateurs utilise la comparaison de pointeurs au lieu de la comparaison de chaˆınes: deux identificateurs de même nom ne sont pas forcément égaux.

Quelques fonctions importantes:

(5)

• exp print: un “pretty”-printer très simple. Les identificateurs sont im- primés avec un suffixe<xxx> qui indique leur adresse pour qu’on puisse facilement distinguer les identificateurs de même nom.

• exp check: calcule et v´erifie le type d’une expression.

• exp unique vars: renouvelle chaque identificateur pour qu’il soit unique.

E.g. tranforme

letxh12i= 1in letxh12i= 2 inxh12i en

letxh27i= 1in letxh78i= 2 inxh78i.

Cela a l’avantage de réduire le risque de capture de nom lorsqu’on manipule le code, par exemple lorsqu’on le déplace. De plus, cela simplifie la gestion mémoire puisque ces nouveaux identificateurs sont garantis “frais”, donc ils ne sont utilisés nulle part ailleurs et peuvent par conséquent être libérés plus facilement.

4 Ce que vous devez faire

Vous avez deux parties `a coder:

• d’abord il faut coder la fonctionexp freedansexp.c qui libère l’espace mémoire utilisé par une expression. Pour cela, il vous faudra utiliser la fonctiontype freequi s’occupe de libérer l’espace occupé par une expression de type.

• ensuite il faut compl´eter la fonction exp optimize qui doit faire de la propagation de constantes et de la substitution d’argument, qui ensemble font ce qui s’appelle duinlining. Pour cela vous devrez entre autre coder la fonctionexp copy.

4.1 Lib´ erer la m´ emoire

Cette partie du TP est la plus simple. Il vous faudra simplement vous assurer que vous avez correctement libéré toute la mémoire utilisée par l’expression, et pas plus. Sur les machines GNU/Linux vous pouvez utiliser la fonctionalité deMALLOC TRACE qui vous permet de voir les blocs que le programme n’a pas libérés. Note: certains de ces blocs sont hors de votre contrôle (e.g. ceux utilisé de manière interne par l’analyseur lexical et l’analyseur syntaxique), donc c’est normal simtracevous dit qu’il y a encore des blocs non libérés. Pour plus d’info surMALLOC TRACEet mtrace, voyez la documentation online de GNU libc. En bref, dans uml.c décommentez le #define IFT2030 MTRACE, et ensuite faire make runmtrace.

(6)

4.2 Optimisation

Vous devez compl´eter la fonctionexp optimizequi doit faire deux op´erations:

la propagation de constantes et la substitution d’arguments. Pour cela vous devrez coder la fonctionexp copy.

La propagation de constantes est une optimisation qui remplace une variable par sa valeur, si cette valeur est connue. Par exemple:

letxh27i= 1inxh27i+ 2 ⇒ letxh27i= 1in1 + 2

Elle s’applique non seulement aux constantes entières mais aussi aux chaˆınes de caractères, aux variables, et aux petites fonctions (celles annotées inlinable).

La fonctionexp copiable pqui détermine si une expression peut être propagée par la propagation de constantes est fournie.

Cette optimisation est généralement combinée avec d’autres optimisations telle que l’élimination de code mort (qui enlèverait la variable xh27i) ou le constant foldingqui remplacerait le 1 + 2 par 3. L’élimination de code mort est fournie. Dans ce TP nous ne nous concentrerons à la place sur l’inlining: une fois qu’une fonction est copiée à l’endroit où elle est appelée, on peut substituer les arguments actuels pour les arguments formels.

Par exemple, avant d’appelerexp optimize, le code source:

let scaledadd (x:int) (y:int) = x + y * 4 in scaledadd 5 6;

a été transformé en:

(let ((scaledadd’<c6b>

(fn [x<f43> : int, y<ebb> : int]

(app + x<f43> (app * y<ebb> 4)))) (scaledadd<a63>

(fni x<f13> : int (fni y<e7b> : int

(app scaledadd’<c6b> x<f13> y<e7b>))))) (app (app scaledadd<a63> 5) 6))

Remarquer que la fonctionscaledadda été divisée en deux: une fonctionscaledaddha63i qui est curried comme dans le code source et qui est marquée inlinable (ce qui explique l’usage de fni au lieu de fn) et qui appelle une autre fonction scaledadd’hc6bi qui elle prend deux arguments. La fonction scaledaddha63i s’appelle ununcurry wrapper.

Le code deexp optimizequi vous allez écrire devrait être capable d’effectuer les étapes suivantes. D’abord propagation de la constantescaledaddha63i:

(app + x<f43> (app * y<ebb> 4)))) (scaledadd<a63>

(fni x<f13> : int (fni y<e7b> : int

(7)

(app scaledadd’<c6b> x<f13> y<e7b>))))) (app (app (fni x<a54> : int

(fni y<c21> : int

(app scaledadd’<c6b> x<a54> y<c21>))) 5)

6))

Notez que les variables déclarées dans le code copié doivent être renommées (renommageα) pour éviter des problèmes de capture de noms. Après cela, une phase d’élimination de code mort transforme le code comme suit:

(app + x<f43> (app * y<ebb> 4))))) (app (app (fni x<a54> : int

(fni y<c21> : int

(app scaledadd’<c6b> x<a54> y<c21>))) 5)

6))

Puis substitution des arguments:

(app + x<f43> (app * y<ebb> 4))))) (app (let ((x<f13> 5))

(fni y<e7b> : int

(app scaledadd’<c6b> x<f13> y<e7b>))) 6))

Puis propagation de constante de nouveau:

(app + x<f43> (app * y<ebb> 4))))) (app (let ((x<f13> 5))

(fni y<e7b> : int

(app scaledadd’<c6b> 5 y<e7b>))) 6))

Puis ´elimination de code mort:

(app + x<f43> (app * y<ebb> 4))))) (app (fni y<e7b> : int

(app scaledadd’<c6b> 5 y<e7b>)) 6))

(8)

Suite `a quoi une substitution d’arguments donne:

(app + x<f43> (app * y<ebb> 4))))) (let ((y<e7b> 6))

(app scaledadd’<c6b> 5 y<e7b>)))

Puis propagation de constante + ´elimination de code mort:

(app + x<f43> (app * y<ebb> 4))))) (app scaledadd’<c6b> 5 6))

On obtient donc finalement une version efficace du code source, où la fonction et son appel ont étéuncurried, i.e. au lieu de passer les deux arguments un à la fois, ils sont passés directement ensemble.

Notez comme la fonctionexp optimizeexécute de manière itérative la fonctionexp deadcodeet la fonctionexp optimize. L’ordre exact des opérations ci-dessus dépend de détails de comment vous allez implanter l’optimisation de propagation de constante et de substitution des arguments, donc il se peut que dans votre cas certaines étapes soient combinées, ce qui ne peut être que bénéfique.

Bien sûr dans cette deuxième partie du TP, il faut aussi faire attention à correctment gérer la mémoire: ne pas oublier de libérer tout ce qui doit l’être.

5 Notes

Vous devez remettre deux fichiers: exp.cet rapport.pdf.

Les commandes pour remettre ces fichier sont les suivantes: pour la premi`ere partie:

% remise ift2030 tp2 exp.c

puis pour la deuxi`eme:

% remise ift2030 tp2 rapport.pdf exp-final.c

• Vous pouvez bien sûr définir de nouvelles fonctions, mais vous ne devriez pas modifier de fonctions autres que celles mentionnées. Vu que vous n’allez remettre queexp.c, il est évident que vous ne pouvez pas changer les autres fichiers.

• Tout usage de matériel (code ou texte) emprunté à quelqu’un d’autre (ou trouvé sur le web) doit être dûment mentionné, sans quoi cela sera considéré comme du plagiat.

(9)

• Chaque ligne de code doit faire moins de 80 caractères. Tout dépassement sera considéré comme une erreur.

• Votre code doit compiler avecgcc -Wallsans g´en´erer plus d’avertissement que le code fourni.

• Vérifiez la page web du cours, pour d’éventuels errata, et d’autres indica- tions supplémentaires.