La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

La machine virtuelle de.NET:CLR(Common Language Runtime) Pr ZEGOUR DJAMEL EDDINE Ecole Supérieure dInformatique (ESI)

Présentations similaires


Présentation au sujet: "La machine virtuelle de.NET:CLR(Common Language Runtime) Pr ZEGOUR DJAMEL EDDINE Ecole Supérieure dInformatique (ESI)"— Transcription de la présentation:

1 La machine virtuelle de.NET:CLR(Common Language Runtime) Pr ZEGOUR DJAMEL EDDINE Ecole Supérieure dInformatique (ESI)

2 La machine virtuelle de.NET:CLR(Common Language Runtime) Architecture Organisation de la mémoire Code IL et méta données générés Ensemble des instructions de la CLR

3 Architecture de la CLR Cest quoi une machine virtuelle (VM)? Un CPU implémenté sous forme dun programme (software) Commandes seront interprétées / JIT-compiled Autres exemples: Java-VM, Smalltalk-VM, Pascal P-Code Le CLR est une machine à pile pas de registres à la place,il y a une pile dexpressions (dans laquelle les valeurs sont chargées) esp estack Taille maximale rangée dans les méta-données de chaque méthode esp... pointeur de la pile dexpressions La CLR exécute du bytecode JIT compilé Chaque méthode est compilée avant la première exécution (= just-in-time) Les opérandes sont adressées symboliquement en IL (information rangée dans les méta-données)

4 Architecture de la CLR: machine à pile Exemple instruction i = i + j * 5; Suppose les valeurs suivantes de i et j Simulation instructionspile ldloc.0 Charger la variable se trouvant à ladresse 0 (c.a.d. i) 3 add Ajouter les 2 éléments en sommet de pile 23 lldloc.1 Charger la variable se trouvant à ladresse 1 (c.a.d. j) 34 ldc.i4.5 Charger la constante mul Multiplier les 2 éléments en sommet de pile 320 stloc.0 Ranger lélément en sommet de pile à ladresse 0 A la fin de chaque instruction la pile dexpression est vide! 3 4j i0 1 locals

5 La machine virtuelle de.NET:CLR(Common Language Runtime) Architecture Organisation de la mémoire Code IL et méta données générés Ensemble des instructions de la CLR

6 Organisation de la mémoire Variables globales statics Représentent les champs statiques de la classe program dans la CLR Les variables globales sont accessibles dans tout le programme Les variables globales sont adressées par des unités medadata Ex. ldsfld T fld charge la valeur du champ référencé par T fld sur la pile estack Type de lunité (1 Octet) index dans la table metadata (3 Octets) Les unités Metadata sont des valeurs à 4 octets qui référencent des lignes dans les tables metadata.

7 Organisation de la mémoire État dune méthode La CLR gère des zones séparées pour Les arguments (args) Les variables locales (locals) La pile dexpressions (estack) Chaque appel de méthode a son propre état (MS) Les états de méthodes sont gérés dans une pile Chaque paramètre et chaque variable locale occupent un espace qui dépend du type. Les adresses sont des numéros consécutifs reflétant lordre de déclarations Ex.ldarg.0 charge la valeur du premier argument de la méthode sur la pile estack ldloc.2 charge la valeur de la troisième variable locale sur la pile estack args locals estack État de la méthode MS P P Q MS Q MS P R MS Q MS R P appelle Q; Q appelle R

8 Organisation de la mémoire Le tas (Heap) Contient les objets classe et tableau 0 heap k free Les nouveaux objets sont alloués à la position free (et free est incrémenté); Ceci est fait par les instructions CIL newobj et newarr Les objets sont libérés par le garbage collector

9 Organisation de la mémoire Les objets class class X { int a, b; char c; } X obj = new X; a b c heap obj adressé par le champ relatif à obj Les objets array int[] a = new int[4]; a[0] a[1] a[2] heap a adressé par la valeur dindice relative à a a[3] Seuls les vecteurs peuvent être maniés par les directives CIL spéciales newarr, ldlen, ldelem, stelem

10 Organisation de la mémoire Le tas Heap 0 k free args locals estack MS S MS P MS Q MS R Pile dexécution Variable globales Statics Les différentes zones de données à un moment donné : Méthode P appelle Q; Q appelle R; R appelle S. Méthode S en cours dexécution

11 La machine virtuelle de.NET:CLR(Common Language Runtime) Architecture Organisation de la mémoire Code IL et méta données générés Ensemble des instructions de la CLR

12 Code IL à générer Un programme.NET compilé est un assemblage (Assembly) Un assemblage est composé de modules. En général, un seul module (=programme) Le programme est un ensemble de types (classes) Chaque type est un ensemble de méthodes Une méthode contient du code machine pour la CLR (= Common Intermediate Language (CIL)) et des méta-données sous forme de tables. Nous utiliserons les classes du domaine System.Reflection.Emit de la BCL (.NET Base Class Library) afin de - générer le IL - produire les méta-données dans le format adéquat. Structure du programme à obtenir Comment lobtenir ?

13 Code IL à générer public class Code { const FieldAttributes GLOBALATTR = FieldAttributes.Assembly | FieldAttributes.Static; const FieldAttributes FIELDATTR = FieldAttributes.Assembly; const MethodAttributes METHATTR = MethodAttributes.Assembly | MethodAttributes.Static; const TypeAttributes INNERATTR = TypeAttributes.Class | TypeAttributes.NotPublic; const TypeAttributes PROGATTR = TypeAttributes.Class | TypeAttributes.Public; //----- System.Reflection.Emit objects for metadata management static AssemblyBuilder assembly; // metadata builder for the program assembly static ModuleBuilder module; // metadata builder for the program module static TypeBuilder program; // metadata builder for the main class static TypeBuilder inner; // metadata builder for the currently compiled inner class internal static ILGenerator il; // IL stream of currently compiled method //----- metadata generation internal static void CreateMetadata (Symbol sym) {... } // instruction generation /* Load the operand x onto the expression stack. */ internal static void Load (Item x) {... } /* Generate an assignment x = y. */ internal static void Assign (Item x, Item y) {... } … }

14 Code IL à générer Chaque méthode est composée dun flot dinstructions CIL et de méta-données comme.entrypoint,.locals,.maxstack, attributs daccès,... La classe System.Reflection.Emit.ILGenerator gère le flot CIL. On peut accéder au flot IL de la méthode en cours de compilation via le champ statique internal static ILGenerator il; de la classe code class ILGenerator { /* overloaded (see next slide) */ virtual void Emit (OpCode op,...); /* for method calls */ void EmitCall ( OpCode op, MethodInfo meth, Type[] varArgs);... } Les instructions sont définies dans la class OpCodes. static readonly OpCode LDARG0= OpCodes.Ldarg_0,... LDARG= OpCodes.Ldarg_S,... LDC0= OpCodes.Ldc_I4_0,... ADD= OpCodes.Add,... BEQ= OpCodes.Beq, ; Ex.: pour générer ldloc.2 Code.il.Emit(LDLOC2);

15 Code IL à générer : méthodes Emit class ILGenerator {// use for the following IL instructions: void Emit (OpCode);// ldarg.n, ldloc.n, stloc.n, ldnull, ldc.i4.n, ld.i4.m1 // add, sub, mul, div, rem, neg, // ldlen, ldelem..., stelem..., dup, pop, ret, throw void Emit (OpCode, byte);// ldarg.s, starg.s, ldloc.s, stloc.s void Emit (OpCode, int);// ldc.i4 void Emit (OpCode, FieldInfo);// ldsfld, stsfld, ldfld, stfld void Emit (OpCode, LocalBuilder);// ldloc.s, stloc.s void Emit (OpCode, ConstructorInfo);// newobj void Emit (OpCode, Type);// newarr void Emit (OpCode, Label);// br, beq, bge, bgt, ble, blt, bne.un /* for method calls */ void EmitCall (OpCode, MethodInfo, Type[]);... }

16 Meta-données à générer La méthode CreateMetadata de la classe Code crée des objets méta-données à partir des nœuds de type Symbol (invoquée pour chaque symbole rajouté à la table des symboles) La classe Code possède des champs pour gérer dimportants éléments de méta-données: static AssemblyBuilder assembly;// the program assembly static ModuleBuilder module;// the program module static TypeBuilder program;// the main class static TypeBuilder inner;// the currently compiled inner class Décrivent les propriétés des composants dun assemblage (types, champs, méthodes,...).

17 Meta-données à générer internal static void CreateMetadata (Symbol sym) { switch (sym.kind) { case Symbol.Kinds.Prog: AssemblyName aName = new AssemblyName(); aName.Name = sym.name; assembly = AppDomain.CurrentDomain.DefineDynamicAssembly( aName, AssemblyBuilderAccess.Save); module = assembly.DefineDynamicModule(sym.name + "Module", sym.name + ".exe"); program = module.DefineType(sym.name, TypeAttributes.Class | TypeAttributes.Public); inner = null; break;... } Exemple1 : pour un programme

18 La CLR gère les deux comme des champs (champ statique de la class program; champ de la classe courante). La méthode DefineField de TypeBuilder génère les méta-données pour les champs. Champs additionnels pour les nœuds de type Symbol internal FieldBuilder fld; pour générer les accès aux champs (ldsfld, stsfld, ldfld, stfld). internal static void CreateMetadata (Symbol sym) { switch (sym.kind) { case Symbol.Kinds.Global: if (sym.type != Tab.noType) sym.fld = program.DefineField(sym.name, sym.type.sysType,FieldAttributes.Assembly | FieldAttributes.Static); break; case Symbol.Kinds.Field: if (sym.type != Tab.noType) sym.fld = inner.DefineField(sym.name, sym.type.sysType, FieldAttributes.Assembly); break;... } Meta-données à générer Exemple2 : pour les variables globales et champs dune structure

19 La machine virtuelle de.NET:CLR(Common Language Runtime) Architecture Organisation de la mémoire Code IL et méta données générés Ensemble des instructions de la CLR

20 Langage Intermédiaire (CIL) (un sous ensemble) Très compacte: instructions sur un octet (la plupart) La plupart non typée; indications de type fait référence au type du résultat Non typée ldloc.0 starg.1 add ldc.i4.3 ldelem.i2 stelem.ref Typée Format des instructions Très simple comparé a Intel, PowerPC ou SPARC Code= { Instruction }. Instruction= opcode [ operand ]. opcode...1 or 2 octets operand...de type primitif ou unité metadata Exemples 0 opérande add a 2 opérandes implicites sur la pile 1 opérande ldc.i4.s 9

21 Ensemble des instructions de la CLR Modes dadressage Comment les opérandes sont accédés? Immédiat ldc.i4 123 pour les constantes Argument ldarg.s 5 pour les arguments de méthode Local ldlocs.s 12 pour les variable locales Statique ldsfld fld pour les champs statiques (fld = unité metadata ) Pile add pour les valeurs chargées dans la pile estack Relatif ldfld fld pour les objet champs (référence objet est dans estack) Indexé ldelem.i4 pour les éléments de tableau (référence tableau et indice sont dans estack) mode dadressageexemple Relatif base address esp estack Indexé base address esp estack index

22 Ensemble des instructions de la CLR Chargement et rangement darguments de méthodes ldarg.n......, val charger (n = 0..3) push(args[n]); ldarg.sb......, val charger push(args[b]); starg.sb..., val... Ranger args[b] = pop(); Types dopérandes b... Octet non signé i... Entier signé T... Unité metadata stloc.n..., val... Ranger (n = 0..3) locals[n] = pop(); stloc.sb..., val... Ranger locals[b] = pop(); ldloc.sb......, val charger push(locals[b]); ldloc.n......, val charger (n = 0..3) push(locals[n]); Chargement et rangement de variables locales

23 Ensemble des instructions de la CLR Chargement et rangement de variables globales stsfldT fld..., val... Ranger une variable statique statics[T fld ] = pop(); ldsfldT fld......, val Charger une variable statique push(statics[T fld ]); Chargement et rangement dobjets champ stfldT fld..., obj, val... Ranger un objet champ val = pop(); obj = pop(); heap[obj+T fld ] = val; ldfldT fld..., obj..., val Charger un objet champ obj = pop(); push(heap[obj+T fld ]); T fld estack adr estack Heap

24 Ensemble des instructions de la CLR Chargement de constantes ldc.i4.n......, n Charge une constante (n = 0..8) push(n); ldc.i4i......, i Charge une constante push(i); ldc.i4.m , -1 Charge la constante -1 push(-1); ldnull......, null Charge la constante null push(null);

25 Exemples: chargement et rangement ax = ay; x 0 y 1 p 2 x y ldarg.11ay starg.s 02- CodeOctetsestack gx = gy;ldsfld T fld_gy 5gy stsfld T fld_gx 5- gx gy statics locals p.x = p.y;ldloc.21p ldloc.21p p ldfld T fld_y 5p p.y stfld T fld_x 5- ax ay args 0 1 x = y;ldloc.11y stloc.01-

26 Ensemble des instructions de la CLR Arithmétiques sub..., val1, val2..., val1-val2 Soustraire push(-pop() + pop()); add..., val1, val2..., val1+val2 Ajouter push(pop() + pop()); div..., val1, val2..., val1/val2 Diviser x = pop(); push(pop() / x); mul..., val1, val2..., val1*val2 Multiplier push(pop() * pop()); neg..., val..., -val Négatif push(-pop()); rem..., val1, val2..., val1%val2 Reste x = pop(); push(pop() % x);

27 Exemples: arithmétiques x + y * 3ldloc.01x ldloc.11x y ldc.i4.31x y 3 mul1x y*3 add1x+y*3 CodeOctetsPile x++;ldloc.01x ldc.i4.11x 1 add1x+1 stloc.01- x--; ldloc.01x ldc.i4.m11x -1 add1x-1 stloc.01- p.x++ldloc.21p dup1p p ldfld T px 5p p.x ldc.i4.11p p.x 1 add1p p.x+1 stfld T px 5- x 0 y 1 p 2 x y locals a 3 int[] t1 4 t2 5

28 Ensemble des instructions de la CLR Création dobjets newarrT eType..., n..., arr Nouveau tableau crée un tableau avec lespace pour n éléments de type spécifié par lunité type newobjT ctor... [ arg0,..., argN ]..., obj Nouvel objet crée un nouveau objet de type spécifié par lunité constructeur puis exécute le constructeur (les arguments sont dans la pile)

29 Exemples: création dobjets Person p = new Person; p0 a1 newobj T P() 5p stloc.01- CodeOctetsPile int[] a = new int[5];ldc.i4.515 newarr T int 5a stloc.11- locals

30 Ensemble des instructions de la CLR Accès aux tableaux stelem.i2 stelem.i4 stelem.ref...,adr, i, val... Ranger un élément de tableau val=pop(); i=pop(); adr=pop()/4+1; heap[adr+i] = val; type de lélément à ranger: char, int, référence objet ldelem.u2 ldelem.i4 ldelem.ref..., adr, i..., val Charger un élément de tableau i = pop(); adr = pop(); push(heap[adr+i]); type du résultat sur la pile estack: char, int, référence objet i estack adr estack a i ldlen..., adr..., len Obtenir la longueur du tableau

31 Exemple1: accès aux tableaux CodeOctetsPile locals a[2]++ldloc.01a ldc.i4.21a 2 stloc.s 22a stloc.s 12- ldloc.s 12a ldloc.s 22a 2 ldloc.s 12a 2 a ldloc.s 22a 2 a 2 ldelem.i41a 2 a[2] ldc.i4.11a 2 a[2] 1 add1a 2 a[2]+1 stelem.i41- a 0 int[] t1 1 t2 2

32 Exemple2: accès aux tableaux a[i] = b[i+1]; a 0 b 1 ldloc.01a ldloc.21a i ldloc.11a i b ldloc.21a i b i ldc.i4.11a i b i 1 add1a i b i+1 ldelem.i41a i b[i+1] stelem.i41- CodeOctetsPile locals i2 int[]

33 Ensemble des instructions de la CLR Manipulation de la pile pop..., val... Enlever lélément au sommet de pile dummy = pop(); dup..., val..., val, val Duplique lélément au sommet de pile x = pop(); push(x); push(x); Branchement bri... Branchement inconditionnel pc = pc + i pc désigne linstruction courante; i (distance du saut) relative par rapport à la prochaine instruction b i..., x, y... Branchement conditionnel ( = eq | ge | gt | le | lt | ne.un) y = pop(); x = pop(); if (x cond y) pc = pc + i;

34 Exemple: branchements if (x > y) {... }... x 0 y 1 ldloc.01x ldloc.11x y ble...5- CodeOctetsPile locals

35 Ensemble des instructions de la CLR Appel de méthode callT meth... [ arg0,... argN ]... [ retVal ] Appel de méthode dépiler les arguments de la pile de lappelant estack et les mettre dans args de lappelée; Avant de faire le retour, dépiler la valeur retournée de la pile estack de lappelé et l empiler dans la pile estack de lappelant ret... Retour de la méthode Divers throw..., exc... Throw exception

36 Exemple void Main () int a, b, max, sum; { if (a > b) max = a; else max = b; while (a > 0) { sum = sum + a * b; a--; } static void Main () 0:ldloc.0 1:ldloc.1 2:ble 7 (=14) 7:ldloc.0 8:stloc.2 9:br 2 (=16) 14:ldloc.1 15:stloc.2 16:ldloc.0 17:ldc.i4.0 18:ble 15 (=38) 23:ldloc.3 24:ldloc.0 25:ldloc.1 26:mul 27:add 28:stloc.3 29:ldloc.0 30:ldc.i4.1 31:sub 32:stloc.0 33:br -22 (=16) 38:return adresses a...0 b...1 max...2 sum...3


Télécharger ppt "La machine virtuelle de.NET:CLR(Common Language Runtime) Pr ZEGOUR DJAMEL EDDINE Ecole Supérieure dInformatique (ESI)"

Présentations similaires


Annonces Google