:: Enseignements :: Master :: M2 :: 2012-2013 :: Machine Virtuelle (et bazard autour ...) ::

Invokedynamic, inlining cache et dé-optimisation

Ce TD est la suite du TD précédent, nous allons compléter l'interpreteur en Java en implantant les opérations manquantes comme la création d'objets, l'accès aux champs ou l'appel de méthode.
L'archive au format ZIP contenant une base de code (les classes de l'AST, le rewriter et l'Engine2) est disponible ici

Exercice 1 - Java Engine 2

La classe Engine2 est la suite de la classe Engine du TD précédent. Celle-ci en plus de pouvoir générer de façon paresseuse le code des fonctions et aussi capable de générer des classes (juste des champs plus un constructeurs) correspondant aux classes déclarés avec le mot-clé classdef.

A quoi servent les classes Field et MetaClass ?
A quoi sert la méthode generateClassForClass et quand elle est appelée ?
A quoi servent les méthodes getScriptDefinedClass et getMetaClass ?
En cherche dans un premier temps à pouvoir allouer un objet
```
            classdef A(x, y)
            
            def main():
              a1 = A(1, 3)
              a2 = A(6, 9)
          
```
Quelle est la méthode de bootstrap qui est appelée ?
Compléter le code pour que celui-ci fonctionne.

On cherche maintenant à implanter l'opération is-type (le ~).
Quelle est la méthode de boostrap correspondante ?
Modifier celle-ci pour que le code suivant fonctionne

 
           classdef A(x)
           classdef B(y)
           
           def main():
             a = A(42)
             print(a ~ A)
             print(a ~ B)

On cherche maintenant à implanter l'opération get-field d'accès à un champs.
```
           classdef A(x)
           
           def main():
             a = A(737)
             print(a.x)    // 737
             print(a.foo)  // undefined 
         
```
Rappeler ce qu'est un inline cache et pourquoi c'est la structure de donnée à utiliser ici.
Implanter l'inline cache pour l'accès aux champs.

Exercice 2 - Appel de méthode et invalidation

L'association en une classe et une méthode se fait dynamiquement dans le langage Small, il est donc possible de changer la méthode associer à une classe lors de l'exécution. On veut de plus, que l'accès à une méthode soit inliné par la machine virtuelle si cela est possible, il faudra donc invalider le code des sites d'appels accédant à une méthode d'une classe si celle-ci est modifiée.
On invalidera tous les appels à une classe indépendamment du nom de la méthode car c'est un peu plus simple à implanter.

Implanter le fait de pouvoir ajouter une méthode à la méta-classe ainsi que l'inlining cache correspondant à l'appel de méthode en pré-supposant que une fois enregistrée une méthode d'une classe ne sera pas modifié (donc pas besoin de SwitchPoint pour l'instant).
```
           classdef A(x)
         
           def foo(a, y):
             print(a.x, y)
         
           def main():
             a = A(85)
             A.m = foo
             a.m(43)
         
```
Rappeler comment marche la classe SwitchPoint.

On suppose maintenant qu'une méthode d'une classe peut changer plusieurs fois pendant la durée de vie du script.$
Modifier votre code pour utiliser le mécanisme de dé-optimisation du SwitchPoint pour cela.

          classdef A(x)
         
           def foo(a, y):
             print(a.x, y)
         
           def bar(a, y):
             a.x = y
         
           def doIt(a):
             a.m(43)
         
           def main():
             a = A(85)
             A.m = foo
             doIt(a)
             A.m = bar
             doIt(a)