1 / 24

Mémoire de travail

Mémoire de travail. Exploitation de la mémoire de travail, mécanismes d’allocation et de virtualisation, dans les systèmes informatiques Par Gilles Grimaud U niversité des S ciences et T echnologies de L ille http://www.lifl.fr/~grimaud/Cours. Plan.

nehru-garza
Download Presentation

Mémoire de travail

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Mémoire de travail Exploitation de la mémoire de travail, mécanismes d’allocation et de virtualisation, dans les systèmes informatiques Par Gilles Grimaud Université des Sciences et Technologies de Lille http://www.lifl.fr/~grimaud/Cours

  2. Plan • Place et fonctionnement de la mémoire dans les systèmes informatique. • Abstractions pour la mémoire centrale • Stratégie d’allocation de la mémoire • Virtualisation de la mémoire • Espace d’adressage des processus selon Linux • Autres usages pour la mémoire virtuelle • Fichiers mappés en mémoire virtuelle

  3. Place de la mémoire de travail dans les systèmes informatiques Processeur Mémoirevive Bus d’adresses 32 bus Connecteur MMU Lecture / Ecriture Mémoirevive Bus de données 32 CPU • contrôleur de disque :o) • ROM • Connecteurs AGP • … AGP RAM N.B. PCI IDE S.B. EISA

  4. Fonctionnement de la mémoire de travail Fonctionnellement, la mémoire de travail permet d’associer, une valeur à une adresse. adresse adresse Valeur Valeur 0x00000000 0x 00200000 01 23 45 67 ROM 0x 00200004 89 AB CD EF 0x00010000 0x 00200008 01 23 45 67 0x 0020000C 89 AB CD EF 0x 00200010 01 23 45 67 RAM 0x 00200014 89 AB CD EF ... ... 0x00020000 Espace d’adressage 0x00220000 HW Interface Exemple de plan d’adressage  Point de vue proc

  5. Exploitation de la mémoire de travail Le microprocesseur accède à la mémoire soit : • Pour lire une instruction à exécuter (lire à l’adresse PC) • Pour lire une donnée en mémoire :Sur ARM par exemple, lorsque l’instruction à exécuter est un :LDR Rx,(Ry,Rz LSL #dec) • Pour écrire une donnée en mémoire :Sur ARM avec une instruction du type :STR Rx,(Ry,Rz LSL #dec) LDR R1, (R3, R4 LSL #dec) adresse Valeur Avant : R3 = 0x00200000R4 = 0x00000005dec = 2 0x 00200000 01 23 45 67 0x 00200004 89 AB CD EF  = 4x5 = 20 0x 00200008 01 23 45 67 0x 0020000C 89 AB CD EF 0x 00200010 01 23 45 67 R1 = 0x89ABCDEF Après : 0x 00200014 89 AB CD EF ... ...

  6. Exploitation de la mémoire de travail On accède à la mémoire de travail lorsqu’une valeur de travail est manipulée par un programme est qu’elle n’est pas associée à un registre du microprocesseur. Exemple : Avec i  R4 et j  R1 et t  R3 … MOV R4, #5 STR R4, (R3, R4 LSL #2) LDR R1, (R3, R4 LSL #2) { int i,j; int t[10]; i = 5; t[i] = i; j = t[i] ; } LDR R1, (R3, R4 LSL #dec) adresse Valeur Avant : R3 = 0x00200000R4 = 0x00000005dec = 2 0x 00200000 01 23 45 67 0x 00200004 89 AB CD EF  = 4x5 = 20 0x 00200008 01 23 45 67 0x 0020000C 89 AB CD EF 0x 00200010 01 23 45 67 R1 = 0x89ABCDEF Après : 0x 00200014 89 AB CD EF (ou R1 = 0xEFCDAB89 little-endian) ... ...

  7. Abstractions pour la mémoire de travail : « la pile d’appel » En C : int main(int argc, char **argv) { int i = foo(1,2); return i; } int foo(int t,int u) { int v; v = t + u; return i; } SP : StackPointer (R13 sur ARM) Sens de la pile 0xAFEC v : - 0xAFF0 @ retour de foo (dans main) 0xAFF4 u : 0x00000001 0xAFF8 t : 0x00000002 0xAFFC @ retour main(vers le système) valeur Adresse Arguments empilés du dernier au premier

  8. Abstraction pour la mémoire de travail : « la pile d’appel » Valeur en mémoire adresse Selon Java : Class c { static void main(String[]args) { int v1; C v2 = new C(); v1 = v2.b(); } int b() { int v3 = 1 + this.c(2); return v3; } int c(int i) { return 3-i; } } TOS … 0144 2 TOS 0140 3 Frame n°3 :méthode c() 013C VM Zone (return address) 0138 0134 État de la pile à ce point int i = 2 2 0130 this = @0x00012A30 @0x00012A30 012C 1 0128 VM Zone (return address) 0124 Frame n°2 :méthode b() Top Of Stack 0120 C v3 = @0x0012A30 011C int v3 = 0 0118 @0x00012A30 this = @0x00012A30 0114 VM Zone (return address) 0110 010C Frame n°1 :méthode main() 0108 arguments C v2 = @0x00012A30 0104 Locals int v1 = 0 0100 String[] args = …

  9. Allocation / Libération de mémoire dans la pile d’appel C En C : Déclaration des arguments, des variables locales (critiques lors d’appels récursifs). Déclaration de tableaux en variables locales. Exemple : int foo(int i) { int t[5]; int *p1, *p2; p1 = &i; // p1 = 0x0000AFFC p2 = str; // p2 = 0x0000AFE4 } SP : StackPointer (R13 sur ARM) t[0] 0xAFE4 0xAFE8 t[1] 0xAFEC t[2] 0xAFF0 t[3] 0xAFF4 t[4] 0xAFF8 @ retour de foo() 0xAFFC i : 0x00000002 valeur Adresse p1 et p2 ont pu être associés à desregistres donc ils ne sont pas présents surla pile. Mais i ne peut pas être un registre(sinon &i est indéterminée). Intérêt de l’allocation en pile : Efficacité.Limites de l’alloc en pile : Programmation fonctionnelle.

  10. Abstraction pour la mémoire de travail : « le tas » But : pouvoir utiliser des données dont la durée de vie n’est ni associées à un bloc de code (≠ variables locales) ni associées à la durée de vie du programme entier (≠ variables globales). En C utilisation de void *malloc(int size); pour l’allocation, et void free(void *ptr); pour la libération.

  11. Stratégie d’allocation dans le tas :« liste de blocs » • Initialement : • Un bloc libre de taille : la taille de la mémoire disponible pour le tas • Une liste chaînée de blocs libres • Une liste des blocs alloués • Allouer : chercher un bloc libre de taille suffisante. Deux stratégies : • Prendre le premier bloc libre satisfaisant : « first fit » • Prendre le bloc libre le plus proche de la taille fixée : « best fit » • Libérer : déclarer le bloc occupé libre. • Fusionner le bloc avec ses voisins libres (constituer des bloc libres les plus grands possibles) Premier utilisé Premier libre Avant utilisation : Sys_info Premier utilisé Premier libre Après utilisation : Sys_info Sys_info Sys_info Sys_info Sys_info

  12. Stratégie d’allocation dans le tas :« arbres dichotomiques » • Initialement : • Un bloc, ou une série de blocs déclarés vides • Allouer : • Chercher un bloc libre de la taille la plus proche de la taille demandée • Marquer ce bloc comme bloc feuille occupé • Libérer : • Supprimer le bloc feuille occupé, et le marquer libre. • Si le bloc frère (issu du même bloc père) est libre, marquer le bloc père comme libre. Espace réellement utilisé 128 octets 64 octets 32 octets 8 8 16 Les principales suites de subdivision utilisé sont : Un+1 = 2.Un ou Un+2 = Un+1 + Un (Fibonatchi)

  13. Stratégie d’allocation dans le tas :« reaps » Algorithme notamment utilisé sur les systèmes Unix : • Constat initial : Quelques tailles fixes = 80% des demandesvoir figure ci-contre  occurrences Listes de blocs libres de taille variable : Taille libre SysNfo SysNfo Taille d’allocation Listes de blocs libres de taille fixe : Taille n°4 SysNfo SysNfo SysNfo SysNfo SysNfo Taille n°3 SysNfo SysNfo SysNfo SysNfo Taille n°2 SysNfo SysNfo SysNfo SysNfo Taille n°1 SysNfo SysNfo SysNfo SysNfo SysNfo SysNfo SysNfo

  14. Tas d’allocation Exemple d’un modèle mémoire pour exécuter un programme C Morcellement de la mémoire pour servir les abstractions du C. Section de code Initialisation au chargement du programme. Section de variablesglobales Espace d’adressage géré par le C Allocation / Libération dynamique. Evolution avec les appels de procédures. Pile d’exécution

  15. @ @’ Processeur 32 32 MMU data data 32 32 Signaux d’interruption Virtualisation de la mémoire : les MMUs MMU : Memory Management Unit Filtre les adresses accédées par le microprocesseur. Permet de transformer une adresse virtuelle en adresse réelle. Exemple du mode protégé depuis les i386 (PC) : Adresse virtuelle sur 32 bits : I1 I2 Offset 10 bits 10 bits 12 bits Registre dédié : Global Translation Table 1ère offset 2ème i1ème i2ème … … … • La MMU gère un cache de translation d’adresse… • Gérer des interruptions en cas de problèmes. 1023ème 1023ème Offset dans La page 1024 @ de tablesde 2ème niveau 1024 @ de pagesde mémoire physique

  16. Virtualisation de la mémoire : les TLBs 20 bits 12 bits MMU par simple TLB (Translation Lookaside Buffer). Modèle matériel simplifié de MMU. Adresse virtuelle sur 32 bits : Adresse réelle sur 32 bits : Pour obtenir « Base ’ » : soit Base est dans la TLB Base’ = TLB[Base]soit Base n’est pas dans la TLB : interruption pour résoudre Base en Base’ Base Offset Base ‘ Offset La TLB : mémoire associative Base (20 bits) Base ‘ (20 bits) Accès Usage 0x1000A 0x00000 RWX 000100001 001000001 0x1003 0x0000A RWX 0x10004 0x0000B RWX 000011110 0x20000 0x10000 RWX 100000000 --- LOCK 0x00000 0x00000

  17. Virtualisation de la mémoire : Isolation & partage Le système de mémoire virtuelle permet de : • Isoler les accès en mémoire • Partager* la ressource mémoire : Page utilisée : Page libre Pages de mémoire virtuelleProcessus n°1 Pages de mémoire virtuelleProcessus n°2 P* Pages de mémoire physique * Dans les deux sens : la mémoire est répartie entre les processus et les processuspeuvent utiliser simultanément la même zone mémoire (P*) s’ils le souhaitent.

  18. Virtualisation de la mémoire : les supports d’échange Augmenter virtuellement la taille de la mémoire de travail. Déplacer les données les moins utilisées vers un autre support de mémoire. Mémoire virtuelle Mémoire Physique Mémoire virtuelle Mémoire de travail Mémoire « système » P2: M1 Disque Microprocesseur P3: M5 P4: - D1: M4 P5: M2 D2: - D3: M3

  19. Architecture de la mémoire de travail dans Linux Code appli. Code appli. Code appli. Processus (lourd) Processus (lourd) Processus (lourd) Logicielapplication Librairie d’allocation Librairie d’allocation Librairie d’allocation bibliothèque« libc » Mémoire virtuelle Mémoire virtuelle Mémoire virtuelle Logiciel Système autonome Gestionnaire de mémoire physique Mémoire de travail Mémoire secondaire (échange) Matériel

  20. Espace d’adressage des processus selon Linux (i386) valeur adresse 0x00000000 #include <stdio.h> int globalVar = 3; int main(int argc, char **argv) { int localVar ; void *ptr = malloc(10); printf("@globalVar: 0x%08X\n", &globalVar); printf("@localVar: 0x%08X\n", &localVar); printf("ptr : 0x%08X\n", ptr); printf("@main() : 0x%08X\n", &main); return 0; } Segment de Text – (Code –) 0x08048400 0x0804852B Données initialisées 0x08048800 Données vierges (BSS) Le tas La pile Pile d’exécution 0xBFFFFFFF 0xC0000000 Zone système Carte de la mémoire virtuelle d’un processus Unix

  21. Mémoire virtuelle, appels systèmes et interruptions Le système d’exploitation repose sur l’espace d’adressage physique. Les autres programmes sont « mappés » à l’intérieur de cet espace. Ils ne « voient » pas le système. « Exécuter une routine système = Interruption »On parle d’interruption logicielle. Section de code Données init. Données init. Section de code Tas Pile Tas Pile Application n°1 : Application n°2 : A. n°1 A. n°2 Programme système : Section de code Données init. Données dans le tas (non initialisées) Pile

  22. Fichiers mappés en mémoire centrale Un exemple de translation de symboles entre différents mécanismes de liaisons… void *mmap((void *) NULL, long mapSize, int fileAccess, int mapProperty, int fileid); Exemple d’utilisation (avec la bibliothèque sys/mman.h) : void *MapFileRW(char* file) { void *ptr; struct stat st;if( stat(file,&st) != 0 || (fd = open(file, O_RDWR)) < 0 ) { printf("%s cannot bee read\n",file); return NULL; } ptr = mmap((void *) NULL, (size_t) st.st_size, (int) PROT_READ | PROT_WRITE, (int) MAP_FILE | MAP_VARIABLE | MAP_SHARED, (int) fd, (off_t) 0);close(fd);if( (caddr_t) ptr == (caddr_t) -1 ) { printf("%s: cannot map",file); return NULL;}return ptr; }

  23. Fichiers mappés en mémoire centrale Utiliser (au moins) une page de mémoire physique pour supporter les écritures faites vers un fichier « mappé » en mémoire virtuelle. Pages de mémoire virtuelle T : page de mémoire physique qui joue le rôle de Tampon entre la mémoire virtuelle et les blocs du volume. T Pages de mémoire en RAM Blocs sur le disque Bloc de groupement du fichier (inode) :

  24. Autres usages pour lamémoire virtuelle Mémoire virtuelle distribuée : Programme 1 Programme 2 Programme 3 Programme 4 Mémoire virtuelle distribuée Unité n°1 Unité n°2 Unité n°3 Unité n°4 microprocesseur microprocesseur microprocesseur microprocesseur RAM RAM RAM RAM Réseau local rapide

More Related