Le document traite de l'analyse sémantique et des optimisations dans la génération de code, en mettant l'accent sur le type checking et la gestion des symboles. Il aborde également les techniques d'optimisation, la mémoire des programmes et la gestion automatique de la mémoire avec un focus sur le garbage collector, incluant les algorithmes de référence et mark and sweep. En conclusion, il note que les langages compilés à la volée comme Java et C# peuvent surpasser C++ en termes de performances grâce à leurs capacités d'optimisation avancées.

1. CodeGen
Présenté par Yann Caron
skyguide
ENSG Géomatique

2. Plan du cours
Analyse sémantique
Optimisations
Code Generation
Garbage collector

3. Analyse sémantique

4. Analyse sémantique
✔ Définition :
✔ Analyse du sens des éléments du
programme
✔ Plusieurs opérations :
✔ Contrôle des types (type checking)
✔ Optimisation locales
✔ Important : Avant l’exécution du
programme
4/72

5. Algorithmes
✔ La plupart des algorithmes d’analyse
sémantique peuvent être exprimés sous la
forme d’un parcours en profondeur de
l'AST
✔ Pré : traitement du nœud n de l’AST
✔ Récursion : traitement des enfants du
nœud
✔ Post : fin du traitement du nœud
✔ Important : L’optimisation peut s’effectuer
par application successive du même
algorithme (algorithme récurrent)
5/72

6. Type Checking
✔ Définition d’un type de variable :
✔ Ensemble des valeurs possible d’une
variable
ex : [0-9]+
✔ Ensemble des opérations possibles sur
ces valeurs
ex : +, -, /, *, %
✔ Les Classes sont une notion moderne des
types
ex : Surcharge des opérateurs C++
6/72

7. Table des symboles
✔ Afin d’effectuer l’analyse des types une
structure de donnée spéciale est
nécessaire
✔ La table des symboles
✔ Trois opérations :
✔ addSymbol : Ajoute les symboles et les
informations tels que le type
✔ findSymbol : Recherche le symbole depuis
le haut de la pile vers le bas (NULL si non
trouvé)
✔ removeSymbol : Supprime l’élément du
haut de la pile 7/72

8. Stack machine
8/72
{{
int xint x
int yint y
Symbol Table
x (int)
y (int)
x (double)
double xdouble x
Recherche
Masquage

9. Table des symboles
✔ Cette structure de donnée ne permet pas
de gérer les contextes différents (appel de
fonctions, de méthodes, objets etc..)
✔ Attention, on ne peut pas compter sur les
stack frames (l’analyse intervient avant
l’exécution)
9/72

10. Table des symboles
✔ Solution :
✔ Rajouter 3 méthodes :
✔ enterScope : Démarre un nouveau
contexte imbriqué
✔ checkScope(x) : vérifie que x soit définit
dans le contexte courant
✔ exitScope : Sort du contexte courant
10/72

11. Type checking
✔ Analyse la sémantique des types
✔ Vérifie que le programme réponde aux
règles fixées par le typage du langage :
✔ Que la valeur respecte le type / class
✔ Que les opérations soient permises
✔ Que la conversion soit permise
✔ Évalue le masquage
11/72

12. Type checking
✔ Analyse statique (basée sur la syntaxe
uniquement et non sur le contexte
d’exécution)
✔ Moins flexible, mais plus sûre
✔ Algorithme basé sur un parcours en
profondeur de l’AST
✔ Entretient la table des symboles
12/72

13. Type checking
13/72
{{int xint x
int yint y
Global scope
x (int)
y (int)
AddSymbol
Démonstration
EnterScope
==
++xx
yy 11
Nested scope 1
Check Assign
Check Operation
Check Type
CheckSymbol

14. Optimisations

15. Optimisations
✔ But :
✔ Rendre plus performant le programme
✔ En terme d’utilisation CPU
✔ Exemple : simplifier les calculs
✔ En terme de recherche des symboles
✔ Exemple : remplacer les variables
✔ En terme d’utilisation de la mémoire
15/72

16. Optimisations
✔ Peu être effectué à plusieurs niveaux :
✔ Sur le code assembleur
✔ Expose les opportunités d’optimisation
✔ Mais est dépendant de la machine
✔ Et doit être réécrit en cas de changement
de machine cible
✔ AST
✔ Indépendant de la machine
✔ Mais de trop haut niveau
16/72

17. Optimisations
✔ Langage intermédiaire
✔ Expose les opportunités d’optimisations
✔ Et est indépendant de la machine
✔ Meilleur compromis
✔ Notion de bloc
✔ Une suite d’instructions sans label (sauf
1ere ligne) ni renvoi (sauf dernière ligne)
✔ Rien qui pourrait en modifier le flot
d’exécution)
17/72

18. Optimisation Assembleur
✔ Peephole
✔ Principe : identifier des portions de code
remplaçables par un code plus efficace
✔ La portion doit être un bloc (ni label, ni
renvoi)
✔ Exemple :
✔ addui $a $b 0 move $a $b
✔ move $a $a peut être supprimé
✔ donc addui $a $a 0 peut être supprimé
18/72

19. Optimisations Locales
✔ S’effectue sur l’AST ou l'IL
✔ Simplification algébrique
✔ Suppression des instructions inutiles
✔ x := x + 0
✔ x := x * 1
✔ Simplification
✔ x := x * 0 x := 0
✔ x:= x ** 2 x:= x * x
19/72

20. Optimisations Locales
✔ Les opérations sur des constantes peuvent
être résolues lors de la compilation
✔ Une opération de type x := y op z
✔ Si y et z sont des constantes
✔ Alors l’opération peut être résolue lors de
la compilation
✔ Exemple :
✔ x := 2 + 2 x := 4
20/72

21. Optimisations Locales
✔ Les conditions qui sont toujours fausses
peuvent être supprimées
✔ Exemple : if 2 < 0 jump 0
✔ Les conditions toujours vraies peuvent être
remplacées
✔ Exemple : if 2 > 0 then jump 0 jump0
✔ Règle générale : Supprimer les blocs qui ne
peuvent êtres atteints
21/72

22. Optimisations Locales
✔ Substituer les opérations
✔ Exemple :
x := y + z
… (sans modification de x, y ou z)
w := y + z w := x
✔ Plus généralement : élimination des
expression communes
22/72

23. Optimisations Locales
✔ Propagation des copies
✔ Exemple :
b := y + z
a := b
x := 2 * a x := 2 * b
✔ De plus, si a n’est pas utilisé autre part
l’expression a := b pourra être supprimée
23/72

24. Exemple
a := 5
x := 2 * a
y := x + 6
t := x * y
24/72
a := 5
x := 10
y := 16
t := x * y
t := 160

25. Optimisations Globales
✔ Analyse du flot d’exécution
✔ Graphe d’exécution
✔ Détection du code jamais exécuté
✔ Propagation des constantes
✔ Analyse des boucles
✔ Dans les langages fonctionnels,
remplacer les récursions par des boucles
✔ Analyse si les variables sont utilisées et s’il
est nécessaire de les calculer
25/72

26. Algorithme récurrent
✔ Observation : chaque optimisation peut en
révéler une autre
✔ Exemple : la propagation des constantes
peut révéler une condition toujours vraie
26/72
a := 5
if a > 0
print a
else
print “error”
print 5

27. Algorithme récurrent
✔ Solution :
✔ appliquer toutes les optimisations
✔ recommencer jusqu’à ce que plus aucune
optimisation ne soit possible
27/72

28. Conclusion
✔ Naïvement on pourrait penser que C++ est
plus performant que Java ou C# (compilé
vs interprété)
✔ Java et C# sont compilés à la volée (JIT)
✔ Le langage intermédiaire permet des
optimisation plus poussées
✔ L’assembleur C++ doit être compatible avec
plusieurs processeurs
✔ Conclusion Java et C# ont de meilleures
performances
28/72

29. Code Generation

30. Mémoire d’un programme
✔ Un programme a un espace mémoire fini
✔ Il a besoin de différentes zones :
✔ Sa propre zone, stocke lui même (fixe)
✔ Une zone pour les constantes (fixe)
✔ Une zone pour l’allocation des objets
(variable)
✔ Une zone pour effectuer des calculs ou
stocker les portées (scopes) (variable)
✔ Comment stocker deux zones variables
dans une zone mémoire fixe ?
30/72

31. Mémoire d’un programme
✔ Code (code
source)
✔ Constantes
✔ Heap (les
objets)
✔ Stack
(scopes)
31/72
Code
Constants / Globals
Heap
(Stockage dynamique)
Stack
(Stockage automatique)

32. Mémoire d’un programme
✔ La stack représente une pile (filo), l’ordre de
libération de la mémoire est relative à celle
de l’allocation
✔ Contient les variables qui sont libérées
lorsque le programme sort du scope
✔ A contrario, le heap est un espace alloué et
libéré de façon indépendante
✔ Contient les objets créés et libérés
✔ Malloc et free en c, new / gc en java
32/72

33. Mémoire d’un programme
✔ Lorsqu’il n’y a plus de mémoire possible :
Stack Overflow ou Out of memory (heap)
✔ Stack overflow arrive le plus fréquemment
lors d’appels récursifs qui dépassent la
limite
✔ Out of memory, lorsque les objets
occupent toute la place mémoire
✔ fuite mémoire en C++
✔ liens persistants en Java (GC)
33/72

34. Stack machine
✔ Basé sur une pile d’exécution
✔ Avantages :
✔ Simplicité d’implémentation
✔ Nombre d’instruction réduit
✔ Code machine généré réduit par rapport
à une machine à registre (code 2x plus
important)
✔ Accès rapide aux opérandes
34/72

35. Stack machine
35/72
77
++
88
**
33
­­
44 // stack machine opcode
push 7 // 7
push 8 // 7 8
push 3 // 7 8 3
multiply // 7 24
add // 31
push 4 // 31 4
substract // 27
// reverse polish
((7 (8 3 *) +) 5 ­)

36. Stack machine
36/72
*
3 3 + -
8 8 8 24 24 4 4
7 7 7 7 7 7 31 31 31 27
Temps
// stack machine opcode
push 7 // 7
push 8 // 7 8
push 3 // 7 8 3
multiply // 7 24
add // 31
push 4 // 31 4
substract // 27
// reverse polish
((7 (8 3 *) +) 5 ­)

37. Stack machine
✔ Inconvénient :
✔ Nécessité de stocker les résultats
intermédiaires en mémoire (coût d’accès)
✔ Nécessite un surcroît d’appel pour stocker
et récupérer les résultats
✔ JVM utilise une modèle hybride avec une
stack et un registre
37/72

38. Stack machine
38/72
xx
xx
11
==
++
load x
push 1
add
store x
Stack
load x (7)
1
Heap
x = 7
0
50
+
Stack
8
store x (8)
Heap
x = 8
0
50

39. Register machine
39/72
22
11
44
++
++
store r0, 2
store r1, 4
add
store r1, 1
add
Registre
2
r1
r0
Registre
4
2
r1
r0
Registre
6
r1
r0
Registre
1
6
r1
r0
+
Registre
7
r1
r0
+

40. Structures de Contrôle
✔ Le langage machine ne connait que 2
instructions de contrôle :
✔ « if » et « goto »
✔ En programmation impérative structurée,
ces instructions ont étés remplacées par
des instructions de plus haut niveau :
✔ for, do / while, repeat / until, if / then / else
40/72

41. Structures de contrôle
41/72
xx
<<
1010
whilewhile
++++
L0 // test
load x
push 10
jump_if_lt L1
jump L2
L1 // body
load x
push 1
add
store x
jump L1
L2 // exit
xx

42. Stack Frames
42/72
Démonstration
A = 4
Constants
Stack
call squareOfSum b = 8, ret
squareOfSum
(x = 4, y = 8)
load x
call square x = 4, y = 8, ret
square
(x = 12)
load x
mult
Heap
x = 12
0
50

43. Portée du programme
43/72
Global
A = 4
square
squareOfSum
main
Global
A = 4
square
squareOfSum
main main
b = 8
squareOfSum
total
main
b = 8
squareOfSum
total
squareOfSum
x = 4, y = 8
z
square
squareOfSum
x = 4, y = 8
z
square
square
x = 12
square
x = 12

44. Pointeurs
44/72
Constants
Stack
Démonstration
a = 4
*p = 10
Heap
10
0
50
100
p = 50
a = 4

45. Garbage collector

46. Garbage collector
✔ La gestion de la désallocation de la
mémoire est automatique en Java
✔ Grâce au ramasse miette (garbage
collector)
✔ La JVM implémente plusieurs algorithmes
46/72

47. Gestion par Destructeur
✔ Contrairement au langage C++ dont la
gestion s’effectue par le destructeur
✔ A la charge du développeur
✔ Nombreux inconvénients :
✔ Fastidieux
✔ Risque de fuites mémoire
✔ Risque d’appel d’éléments détruits
✔ Risque de désallocations multiples
47/72

48. Algorithmes
✔ Reference counting
✔ Pose problèmes
✔ Mark and sweep
✔ Utilisé par la JVM
✔ Tri-color marking
48/72

49. Reference Counting
✔ Principe :
✔ Pour chaque objet, un compteur est
entretenu
✔ Incrémenté en cas d’une nouvelle
référence
✔ Décrémenté en cas de destruction d’un
parent (parcours en profondeur du
graphe)
✔ Quand le compteur est à 0, l’objet peut
être détruit
49/72

50. Reference Counting
50/72
Objet 1 (2)
Objet 2 (1)
Objet 3 (1)
Objet 4 (1) Objet 5 (0)
Objet 6 (1)
Objet 8 (2)
Objet 9 (1)
Objet 7 (0)

51. Reference Counting
51/72
Objet 1 (2)
Objet 2 (1)
Objet 3 (1)
Objet 4 (1) Objet 5 (0)
Objet 6 (1)
Objet 8 (1)
Objet 9 (1)
Objet 7 (0)
Référence
cyclique

52. Reference Counting
✔ Avantages :
✔ Mis à jour en temps réel
✔ Complexité et coûts mémoire faibles
✔ Inconvénients :
✔ Cas des références cycliques (des objets
se référençant mutuellement)
52/72

53. Mark and Sweep
✔ Principe :
✔ Nécessite un flag booléen par objet
✔ Étape 1 : Parcours en profondeur de
l’arbre et marquage des objets utilisés
✔ Étape 2 : Suppression des objets non
marqués
✔ Étape 3 : Nettoyage des flags
53/72

54. Mark and Sweep
54/72
Objet 1
Objet 2
Objet 3
Objet 4 Objet 5
Objet 6
Objet 8
Objet 9
Objet 7

55. Mark and Sweep
55/72
Objet 1
Objet 2
Objet 3
Objet 4 Objet 5
Objet 6
Objet 8
Objet 9
Objet 7

56. Mark and Sweep
56/72
Objet 1
Objet 2
Objet 3
Objet 4 Objet 5
Objet 6
Objet 8
Objet 9
Objet 7

57. Mark and Sweep
57/72
Objet 1
Objet 2
Objet 3
Objet 4 Objet 5
Objet 6
Objet 8
Objet 9
Objet 7

58. Mark and Sweep
58/72
Objet 1
Objet 2
Objet 3
Objet 4 Objet 5
Objet 6
Objet 8
Objet 9
Objet 7

59. Mark and Sweep
✔ Avantages :
✔ Élimination des références circulaires
✔ Inconvénients :
✔ Ne détecte pas si l’objet est dans du code
inaccessible (peu important)
✔ Nécessite un arrêt des accès mémoire
(stop the world) → rends les applications
« temps réel » ou « time critical »
impossibles
59/72

60. Mark and Sweep
60/72
Objet 1
Objet 2
Objet 3
Objet 4 Objet 5
Objet 6
Objet 8
Objet 9
Objet 7
Objet 10
Objet créée en parallèle
sera supprimé

61. Tri-color marking
✔ Principe :
✔ Trois ensembles sont nécessaires
✔ Blanc contient tous les objets à évaluer
✔ Noir, objets qui n’ont pas de lien vers un
objet de l’ensemble blanc et qui sont
atteignables depuis la racine (non
candidats à la collection)
✔ Gris, objets atteignables depuis la racine
mais dont les liens n’ont pas encore été
évalués
61/72

62. Tri-color marking
62/72
Objet 1
Objet 2
Objet 3
Objet 4 Objet 5
Objet 6
Objet 8
Objet 9
Objet 7
Blanc
Gris
Noir
1 2
3 4 5 6
7 8 9

63. Tri-color marking
63/72
Objet 1
Objet 2
Objet 3
Objet 4 Objet 5
Objet 6
Objet 8
Objet 9
Objet 7
Blanc
Gris
Noir
2 3
4 5 7 8
9
1 6

64. Tri-color marking
64/72
Objet 1
Objet 2
Objet 3
Objet 4 Objet 5
Objet 6
Objet 8
Objet 9
Objet 7
Blanc
Gris
Noir
2 3 4
5 7 8 9
1 6

65. Tri-color marking
65/72
Objet 1
Objet 2
Objet 3
Objet 4 Objet 5
Objet 6
Objet 8
Objet 9
Objet 7
Blanc
Gris
Noir
2 3
4
5 7 8 9
1 6

66. Tri-color marking
✔ Principe :
✔ L’ensemble blanc fige l’espace de travail
✔ En cas de génération de nouveaux objets
durant l’exécution, ils ne seront pas pris
en compte
✔ Si des objets sont déréférencés durant
l’exécution, ils seront évalués à la
prochaine exécution
✔ L’ensemble gris sert à décider si
l’algorithme a fini (lorsqu’il est vide)
66/72

67. Tri-color marking
✔ Les objets ne peuvent être déplacés que
du blanc vers le gris et du gris vers le noir
✔ Comme aucun objet noir ne peut
référencer un objet blanc, une fois que
l’ensemble gris est vide les objets peuvent
êtres supprimés
✔ Avantage :
✔ Élimination des références circulaires
✔ Peut être exécuté en parallèle du
programme
67/72

68. Moving vs Non-Moving
✔ Après la collection des objets
inaccessibles, les objets restants peuvent
rester sur place
✔ Ou être recopiés dans une nouvelle zone
mémoire
✔ But : éviter la fragmentation de la mémoire
avec des zones vides
✔ Désavantages :
✔ Coût de la copie
✔ Ne permet plus l’arithmétique de
pointeurs 68/72

69. Moving
69/72
Objet 1
Objet 2
Objet 3
Objet 4 Objet 5
Objet 9
Objet 7
Objet 8
Objet 6

70. Moving
70/72
Objet 1
Objet 2
Objet 3
Objet 4
Objet 9

71. Stop the world vs Concurrent
✔ Les algorithmes Stop the world,
suspendent l’exécution du programme lors
de la collection
✔ Posent des problèmes de performance
✔ Rendent impossible les programmes
Temps réel
✔ Les algorithmes Concurrents rendent
possible la collection sans que le
programme ne soit suspendu
71/72

72. Merci de votre attention