Cours 5 Master 2 SE Université Bretagne Occidentale STICCsyst.univ-brest.fr/boukhobza/images/stories/Documents/... · 2015-12-06 · Gestion de la correspondance entre mémoire logique/physique

Cours 5 ‐Master 2 SEJalil Boukhobza

Université de Bretagne Occidentale – Lab‐STICC

J.Boukhobza - Systèmes d'exploitation embarqués 1

Choix des exposésKremer: ‐> µCOSII ‐> expo 13/11, rapport 5‐6/11Melot: ‐> FreeRTOS ‐> expo 13/11, rapport 5‐6/11Aguercif: ‐> Symbian OS expo 18/11, rapport 11/11Lucas: ‐> Shark ‐> expo 18/11, rapport 11/11Pardo: ‐> comparatif BlueCat & Angstrom ‐> expo 18/11, rapport 11/11Akli: ‐> VxWorks/Jari ‐> expo 18/11, rapport 11/11Jacquet: ‐> RTAI & RTLInux ‐> expo 18/11, rapport 11/11Shen yi: ‐> eCos ‐> expo 18/11, rapport 11/11Medjhoum ‐> ??Ndiaye ‐> RTEMS ‐> expo 23/11 ‐> rapport 18/11

J.Boukhobza-Systèmes d'exploitation pour l'embarqué 2

Modalités1 rapport d’une vingtaine de pages1 exposé d’environ 30mn1 démo (s’il y en a une)À exposer pour dans 6 semaines (2 séances?) À rendre pour dans 5 semaines

J.Boukhobza-Systèmes d'exploitation pour l'embarqué 3

Plan du cours1. Introduction2. Espace noyau / utilisateur3. Segmentation 4. Pagination5. Mémoire virtuelle6. Gestion de la mémoire sous Linux

1. Segmentation2. Pagination


IntroductionMultitâches: plusieurs tâches qui partagent le même espace mémoire:

L’OS a besoin d’un mécanisme de sécurité pour protéger les espaces mémoires des tâches les uns des autres.

L’OS se trouve aussi dans ce même espace mémoire:Gestion de son propre code en mémoireProtection de son propre code de celui des tâches gérées.


Les responsabilités du gestionnaire de la mémoire

Gestion de la correspondance entre mémoire logique/physique et les références mémoire des tâchesDéterminer quelle processus charger dans l’espace mémoire disponible.Allouer et désallouer la mémoire des processus qui constituent le systèmeSupporter l’allocation et la désallocation dynamiques des requêtes du code (au sein d’un processus) exemple: malloc & free.Contrôler et gérer l’usage de la mémoire par les processusAssurer la cohérence des caches (pour les systèmes munis de mémoire cache).Assurer la protection de l’espace d’adressage du processus


Espace noyau/utilisateurGénéralement 2 espaces mémoires:

Espace noyau: contenant le code du noyau ainsi que les structures manipulées par ce dernier.

Blocs de contrôle des tâches.Les différents IPC…

Espace utilisateur: contenant le code des application haut niveau.

Mémoire en mode noyau accédée via des appels système:IPC, caractéristiques d’un fichier,

Contient les éléments mémoire (code, variables, etc) permettant à un processus de s’exécuter


Techniques de gestion de mémoireSwapping: des portions de la mémoire sont rapatriées et envoyées vers l’espace de stockage secondaire.

Permet d’exécuter plus de tâches / ou des tâches de taille plus importanteSegmentation : subdivision des espaces d’adressage d’après leur fonctionnalités.

Permet une meilleure gestion de l’espace mémoire en terme de fonctionnalité (exemple: sécurité, partage, extensibilité)

Pagination : subdivision des espaces d’adressage des tâches en petites tranches de taille fixe

permet d’éviter que la fragmentation externe de la mémoire soit problématique pour la création et l’exécution de tâche.… mais produit de la fragmentation interne.

Mémoire virtuelle: création d’un espace d’adressage important incluant la mémoire physique et une partie de la mémoire secondaire (disque).

Permet à des tâches de très grande taille de pouvoir s’exécuter.


La segmentationL’espace d’adressage d’un processus est constitué de plusieurs unités logiques de mémoire de taille variable contenant des informations différentes appelés segments.Un segment:

Contient plusieurs données du même type (exemple: variables)Commence à une adresse logique 0Est numéroté (chaque segment à un numéro), c’est ce qui indique son adresse, et un déplacement dans ce segment indique l’adresse en mémoire physique de la donnée.A une protection qui peut être différente des autres segments de la même tâche.A une taille différente des autres segments


Les différents types de segments de tâche

Généralement 5 types d’informations pour les segments1. Segment texte (ou code): contient le code source à exécuter

segment statique2. Segment de données: contient les variables initialisées dans

le code source segment statique3. Segment bss (block started by symbol) ou segment de

symboles: contient les variables non initialisés du programme segment statique

4. Segment de pile (stack): espace mémoire en LIFO, utilisé pour stocker les variables locales, arguments, etc. Lors d’appel à des fonctions segment dynamique

5. Segment de tas (heap): contient les espaces alloués dynamiquement (malloc).


L’exécutableLe segment de texte, de données et de symboles sont crées à partir de l’exécutable. L’OS crée une correspondance entre l’image de la tâche en mémoire et le fichier exécutable.Plusieurs format d’exécutable supportés par les OS embarqués, exemple:

Format ELF (Executable and Linking Format): basé sur UNIXClass: byte code javaCOFF (Common Object File Format)


Le format ELFConstitué d’une entête ELF, table d’entêtes de programme, table d’entêtes de section, sections ELF et les segments ELF.Format supporté par Linux (Timesys) et VxWorks.


Entête ELF

Table d’entêtes du programme

Section 1

…

Section 2

…

…

Table d’entête de section

Entête ELF

Table d’entêtes du programme

Segment 1

Segment 2

…

…

Table d’entête de segment

Vue

d’é

ditio

n de

s lie

n

Vue

d’e

xécu

tion

Le format ELF (2).init: instructions exécutables qui contribuent au code d’initialisation du processus..fini: instructions exécutables qui contribuent au code de terminaison du processus..rodata: données en lecture seule..strtab: chaînes de caractères…


Le format classUn fichier class décrit une classe java en détail sous la forme d’un stream (flot) de 8bits (d’où le nom byte code).Ce type de fichier contient la description de la classe ainsi que la description de ses connexion avec d’autres classes. Les principaux composants d’un tel fichier sont:

Une table des symboles (avec les constantes)Déclaration des champsImplémentation des méthodes (code)Références symboliques (références vers les autres classes)

L’RTOS Jbed est un exemple du type de système supportant ce type d’exécutable.


Le format COFFFormat de fichier qui définit une image de fichier contenant les entêtes qui incluent une signature de fichier, une entête COFF, une entête optionnelle ainsi que des fichiers objet ne contenant que des entêtes COFF.Initialement développé pour UNIX, il est actuellement utilisé, entre autre, par WinCE.


Source: http://support.microsoft.com/kb/121460/fr

Segment de pile (stack)Taille non fixée pendant la compilation mais évolue dynamiquement pendant l’exécutionStructurée en LIFO (Last In First Out, pile), 2 opérations possibles:

EmpilerDépiler

Allocation et désallocation de mémoire pour les données dont la taille est prédictible: variables locales, passage de paramètres, etc.L’espace de données réservé dans la pile est contigu mais limité.


Segment de tas (heap)Emplacement mémoire alloué en bloc en cours d’exécution.Liste chaînée d’emplacements mémoire.L’OS doit implémenter des mécanismes d’allocation mémoire pour permettre, par exemple, l’implémentation des malloc (en C).Politiques d’allocation typiques:

FF (First fit): la liste est scannée depuis le début à la recherche du premier emplacement pouvant contenir la donnée.NF (Next Fit): la liste est scannée depuis le dernier emplacement trouvé, à la recherche du premier emplacement pouvant contenir la donnée.BF (Best Fit): toute la liste est inspectée à la recherche du meilleure (plus petit) emplacement pouvant contenir la donnée.WF (Worst Fit): toute la liste est parcourue et la donnée est placée dans le plus grand emplacement.QF (Quick Fit): une liste d’emplacements libres est maintenue et l’allocation est faite à partir de là.Le buddy system: où les blocs sont alloués par puissance de 2. A chaque fois qu’un bloc est libéré, il est fusionné avec les blocs voisins.…


Désallocation de la mémoire (tas)2 possibilités

Explicite: le programmeur doit désallouer lui‐même la mémoire dynamiquement allouée;Implicite: la désallocation est prise en charge par un ramasse miettes (garbage collector):

Algorithme de copie: le système copie toutes les références des objets utilisés et efface le reste.

La copie est une opération inninterruptible, L’espace mémoire requis pour cet algorithme est important.

Algorithme mark & sweep: on marque les objets utilisés et on efface les autres

Pb de fragmentation.Algorithme générationnel: sépare les objets en groupe (générations). Cet algorithme suppose que la plupart des objets crées « vivent » peu de temps. Les objets « vieux » ont donc moins de chance d’être effacés, les copier est, par conséquent, une perte de temps.


Gestion de la mémoire et segmentation sous VxWorks

Après l’appel à taskSpawn()une image de la tâche fils est créée, contenant TCB, pile et programme.

// tâche parent qui active le timervoid parentTask(void){

…if sampleSoftware Clock NOT running {//newSWClkId est une valeur d’entier unique assignée par le noyau lorsque la tâch est créenewSWClkId = taskSpawn (“sampleSoftwareClock”, 255, VX_NO_STACK_FILL, 3000,(FUNCPTR) minuteClock, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);….

}//fonction exécutée par la tâche fille Software Clockvoid minuteClock (void) {

integer seconds;integer minutes=5;while (softwareClock is RUNNING) {

seconds = 0;while (seconds < 60) {

seconds = seconds+1;}

……}

}


pileSegment de code (texte)

Segment des symboles (Bss)

Segment de données

Source: Embedded Systems Architecture: A comprehensive guide for engineers and programmers, Elsiever ed, T. Noergaard, 2005

Allocation et désallocation de mémoire sous VxWorks/* le code suivant est un exemple d’un pilote de périphérique

qui effectue une traduction d’adresse. Il tente d’allouer un buffer , le remplit et l’écrit dans le périphérique. Il utilise CACHE_DMA_FLUSH pour être sûr que les données sont copiées. Le pilote lit, par la suite, les nouvelles données et utilise CACHE_DMA_INVALIDATE pour garantir la cohérence de cache*/

#include “vxWorks.h”#include “cacheLib.h”#include “myExample.h”STATUS myDmaExample (void){

void * pMyBuf;void * pPhysAddr;/* allouer le buffer de cache si possible*/If ((pMyBuf = cacheDmaMalloc (MY_BUF_SIZE)) == NULL)

return (ERROR);… remplir le buffer avec des informations utiles…/* flusher le cache avant que les données ne soient écrites dans le périphérique */CACHE_DMA_FLUSH (pMyBuf, MY_BUF_SIZE);

/* convertir l’adresse virtuelle en adresse physique */pPhysAddr = CACHE_DMA_VIRT_TO_PHYS (pMyBuf);/* programmer le périphérique pour lire les données de

la RAM*/myBufToDev (pPhysAddr);… attendre que le DMA termine…… prêt à lire les nouvelles données…

/* programmer le périphérique pour écrire les donnéesvers la RAM*/

myDevToBuf (pPhysAddr);… attendre que le transfert soit fini…

/* convertir l’adresse physique en adresse virtuelle*/pMyBuf = CACHE_DMA_PHYS_TO_VIRT (pPhysAddr);/* invalider le buffer*/CACHE_DMA_INVALIDATE (pMyBuf, MY_BUF_SIZE);… utilser les données…/* une fois fini, désallouer la mémoire*/if (cacheDmaFree (pMyBuf) == ERROR)

return (ERROR);return (OK);

}


Source: Embedded Systems Architecture: A comprehensive guide for engineers and programmers, Elsiever ed, T. Noergaard, 2005

Allocation mémoire et JbedL’allocation se fait avec le mot clé new.malloc peut être utilisé si la JNI (Java Native Interface) est supportée.Le ramasse miettes de Jbeds’occupe de désallouer la mémoire avec un algorithme mark & sweep, ce qui permet de faire du temps réel (car non bloquant).

public void CreateOneshotTask(){// caractéristiques pour l’ordonnacementfinal long DURATION = 100L; // temps d’exécution< 100usfinal long ALLOWANCE = 0L; // pas de gestion de

dépassement de duréefinal long DEADLINE = 1000L;// terminaison au bout de

1000usRunnable target; // code executable de la tâcheOneshotTimer taskType;Task task;// Création d’un objet exécutabletarget = new MyTask();// Création d’une tâche de type oneShot sans délaitaskType = new OneshotTimer( 0L );// Création de la tâchetry{task = new Task( target, DURATION, ALLOWANCE,

DEADLINE, taskType );

}catch( AdmissionFailure e ){System.out.println( “Echec de création de la tâche ” );return;}


Allocation mémoire et LinuxProcessus Linux:

Segments de texte, données et bssstatiquesSegment de pile et tas dynamiques

void *mem_allocator (void *arg){// trouver un espace libre dans un pool donné et l’allouer

int i;int thread_id = *(int *)arg;int start = POOL_SIZE * thread_id;int end = POOL_SIZE * (thread_id + 1);if(verbose_flag) {

printf(“Allocator %i works on memory pool %i to %i\n”, thread_id, start, end);

printf(“Allocator %i started...\n”, thread_id);}while(!done_flag) {

/* find first NULL slot */for (i = start; i < end; ++i) {

if (mem_pool[i] ==NULL) {mem_pool[i] = malloc(1024);if (debug_flag)

printf(“Allocate %i: slot %i\n”,thread_id, i);break;

}}

}pthread_exit(0);

}

void *mem_releaser(void *arg){

int i;int loops = 0;int check_interval = 100;int thread_id = *(int *)arg;int start = POOL_SIZE * thread_id;int end = POOL_SIZE * (thread_id + 1);if(verbose_flag) {

printf(“Releaser %i works on memory pool %i to %i\n”, thread_id, start, end);printf(“Releaser %i started...\n”, thread_id);

}while(!done_flag) {

/* find non‐NULL slot */for (i = start; i < end; ++i) {

if (mem_pool[i]!= NULL ) {void *ptr = mem_pool[i];mem_pool[i] = NULL;free(ptr);++counters[thread_id];if (debug_flag)

printf(“Releaser %i: slot %i\n”, thread_id, i);break;

}}….

}pthread_exit(0);

}


Espace mémoire noyauLe source du noyau (en cours d’exécution)Accédé via des appels système par l’applicatifExemple: création du TCB (ou PCB) après un fork() espace noyau…


Pagination et mémoire virtuelleAvec ou sans segmentation, les OS divisent la mémoire en partitions de taille fixe appelées: blocs, cadres, pages ou une combinaison de ces derniers.Mémoire découpée en cadres (@: numéro de cadre + déplacement) espace utilisateur (@: numéro de page + déplacement).Pagination: processus chargé en mémoire liste de page.

Table des pages: contient les informations entre la correspondance page/cadre.


Page 0

Page 1

Page 2

Page 3

Numérode page

Numéro de cadre

0 1

1 4

2 3

3 7

Page 0

Page 2

Page 1

Page 3

Mémoire logique Table des pages

Mémoire physique

0

1

2

3

4

5

6

7

Numéro de cadre

Pagination à la demandeDans un système paginé, les processus sont lancés sans qu’aucune de leurs pages ne soit en mémoire :

Dès que le processeur essaie d’exécuter la première instruction, il se produit un défaut de page, ce qui amène le système d’exploitation à charger la page correspondante en mémoire centrale.D’autres défauts de page apparaissent rapidement pour les variables globales ou la pile.C’est seulement au bout d’un certain temps que le processus dispose de la plupart de ses pages et que l’exécution peut se poursuivre avec relativement peu de défauts de page.

Cette stratégie est appelée pagination à la demande car les pages sont chargées à la demande et non à l’avance


Ensemble de travailThéorie de localité de références de Knuth: le système passe 90% du temps à traiter 10% du code.Généralement, les processus font des références groupées, c’est‐à‐dire que pendant une certaine phase de leur exécution ils ne référencent qu’un nombre restreint de leurs pages.

Cet ensemble de pages utilisées pendant un certain temps par un processus constitue l’ensemble de travail du processus.Si l’ensemble de travail est entièrement en mémoire, le processus s’exécute sans provoquer (beaucoup) de défauts de page.

De nombreux systèmes de pagination mémorisent l’ensemble de travail de chaque processus et le chargent en mémoire avant de lancer le processus.

Cette approche est appelée “ Modèle de l’ensemble de travail ”.Le chargement des pages avant exécution est appelé La Préchargement ou Prépagination .


Swapping et algorithme d’allocation

Mémoire physique pleine + besoin de mémoire => swapper des pages sur une mémoire hiérarchiquement inférieure.Différents algorithmes quant au choix de la page à décharger:

Optimal: swapper les pages qui ne vont pas être utilisés dans un futur proche….inimplémentable.LRU (Least Recently Used): swapper la page qui a été utilisée le moins récemment.FIFO: swapper la page qui a été mise en mémoire la première.Not Recently Used: swapper les pages qui n’ont pas été utilisées pendant un certain temps.Seconde chance: FIFO avec un bit de référence, si zéro swapper (ce bit est à 1 si la page est accédée, et remis à 0 après une vérification+ remise de la page en début de liste comme une page nouvellement accédée)…


Mémoire virtuellePlus grand espace adressable (par rapport à la mémoire physique)Demande effectuée par segment de processus ou par processus (globalement).Table de page (Virt Phys): utilisation de TLB (Translation Lookaside Buffer)Utilisation d’MMU pour la traduction d’adresse


C P U

M M U

B u s

Ad re s s e s v irtu e l le s

Ad re s s e s ré e lle s

M é m o irep h y s iq u e

P é r ip h é riq u eC a r te C P U

Disque

Quelques spécificités des OS embarqués et temps réel

Gestion de mémoire rapide et déterministe: il est plus rapide de … ne pas avoir à gérer du tout !!. Le programmeur gère tout (très petit EOS et RTOS). Sinon gestion basique: allocation et désallocation.Verrouillage des pages: évite d’avoir certaines pages sur disque (accès non déterministe) pour les tâches temps réel.Allocation dynamique: pas sûr qu’il y a assez de place, et donc risque de swapping. Il faut faire attention.Mapping mémoire: différents registres des périphériques doivent être accédés par les applications, d’où le besoin de mapping en mémoire de ces derniers.Partage de mémoire (communication): allocation/désallocationRAM disk: utiliser la mémoire comme stockage secondaire pour avoir des temps déterministes (possibilité d’utiliser un disque flash) utilisation d’un système de fichiers.



IntroductionLa tâche de la gestion de la mémoire physique n’incombe pas seulement à l’OS.Les microprocesseurs incluent un support matériel pour rendre la gestion de la mémoire plus performante et plus sûre.Etudié à travers l’exemple de Linux sur une plateforme x86La mémoire peut être adressée de 3 points de vue différents:

Point de vue processeurComment se fait l’adressage de la mémoire physique ?

Point de vue noyauComment le noyau gère la mémoire pour son propre usage ?

Point de vue des processusComment la mémoire est allouée aux processus ?


Adressage mémoireSupport matériel pour l’adressage3 formes d’adressage pour les CPUs x86

Adressage logiqueSpécifie l’adresse d’une opérande et/ou d’une instructionChaque adresse logique est constituée d’un numéro de segment et d’un déplacement (offset)

Adressage linéaire (ou virtuelle)Un entier sur 32bits non signé permettant d’adresser n’importe quelle zone mémoire (4GOctets adressables)

Adressage physiqueAdresse la cellule mémoire sur les bonnes pucesCorrespond aux signaux électriques


Unité de segmentation

Unité de pagination

Adresse logique Adresse linéaire/virtuelle

Adresse physique

Matériel pour la segmentation80286: µproc Intel effectue la traduction d’adresse en 2 modes: 1. Mode réel:

Existe encore à des buts de compatibilitéPas de protection mémoireCPUs précédent n’avaient qu’un unique mode, équivalent à réel

2. Mode protégé:Permet la gestion hardware de la protection mémoireAjout d’un mécanisme de pagination dans le 80386Introduit les niveaux de privilège ou rings

0 a tous les pouvoirs3 très limité


Matériel pour la segmentation (2)Une adresse logique est constituée

D’un identifiant/sélecteur de segment sur 16bitsD’un déplacement/offset représentant une adresse relative dans ce segment sur 32 bits

Le processeur contient des registres pour obtenir l’identifiant/sélecteur de segment

6 registres disponibles: cs, ss, ds, es, fs et gsSi plus de segments, sauvegardes des valeurs en mémoire (…et puis restauration)


Registres pour la segmentation3 registres ont un rôle spécifiquecs: Code Segment

Pointe vers un segment contenant le code (segment texte)Contient un champs de 2 bits qui indique le Current Privilege Level(CPL):

4 privilèges possibles sur les processeur x86 Intel, Linux en utilise 2 (mode utilisateur et mode noyau)

ss: Stack SegmentPointe vers le segment contenant la pile courante du programme

ds: Data SegmentPointe vers le segment contenant les données statiques du programme

Les 3 autres registres (es, fs, gs) peuvent faire référence à des segments arbitraires


Descripteurs de segmentChaque segments est décrit par un descripteur de segment de 8 octets

Stocké dans le LDT ou dans le GDT (Local/Global Descriptor Table)Un registre spécifique contient un pointeur vers le GDT (gdtr) et vers le LDT (ldtr)

Champs du descripteur de segmentBase : 32 bits contenant l’adresse linéaire de début de segmentG : granularité, si 0 la taille segment est exprimé en octets, sinon en multiples de 4Ko (taille d’une page)Limit : 20 bits indiquant la longueur du segment en octetsS : (system flag) Si 0, segment contenant des données critiques pour le noyau, sinon code ou données normales (utilisateur)Type : 4 bits caractérisant le type du segment et ses droits d’accèsDPL : Descriptor Privilege Level, 2 bits indiquant le niveau de privilège minimal pour accéder à ce segmentP: Segment‐Present, indique si le segment est en mémoire principale sous linux toujours 1, un segment n’est jamais entièrement swappé sur le disque.D ou B: à 1 lorsque les déplacements dans le segment (offset) sont sur 32 bits et 0 si sur 16 bits.


Accès au descripteur de segmentsSélecteur/identifiant de segment contient:

Un indice qui identifie le descripteur de segment contenu dans la GDT ou LDT (13 bits).Un indicateur de table: pour dire si le descripteur se trouve dans le LDT ou GDT (1 bit).RPL (Request privilege Level): spécifie le niveau de privilège du CPU lorsque le sélecteur de segment est chargé (2 bits).

Pour accéder au segment: accéder d’abord au registre contenant le sélecteur puis en mémoire (descripteur) lent !

Solution: pour chaque registre de segment, il existe un registre non programmable qui chargera le contenu du descripteur, cela évite de passer par la mémoire.


Traduction d’adresseAdresse logique adresse linéaire (virtuelle)L’unité de segmentation réalise les opérations suivantes:

Examine le bit d’indicateur de table de sélecteur de segment pour savoir si le descripteur est dans la GDT ou LDT:

l’unité de segmentation prend le contenu du registre gdtr comme adresse linéaire de base ou celle du registre ldtr

Trouve l’adresse du descripteur de segment grâce au champ indice *8 octets (taille d’un descripteur de segment).additionne l’offset/déplacement de l’adresse logique à l’adresse de base extraite du descripteur.


indice IT déplacement

*8

+

gdtrou ldtr

descripteur

+Adresse linéaire/virtuelle

Adresse logique

16 bits 32 bits

Segmentation sous LinuxLinux préfère la pagination à la segmentation (si l’on peut opposer ces 2 concepts…):

L’un des objectifs de Linux est la portabilité: plusieurs processeurs RISC ont un support limité pour la segmentation.

Tous les processus linux s’exécutant en mode utilisateur partagent la même pair de segments: code et données (user code segment et user data segment)

Tous les processus linux s’exécutant en mode noyau partagent la même pair de segments: code et données (kernel code segment et kernel data segment).


Segmentation sous Linux (2)Un GDT / processeur 18 descripteurs de segments:

4 segments vus précédemment (data et text utilisateur et noyau)Un segment TSS (Task State Segment) / processeur: censé contenir l’état des registres matériels lors d’un changement de contexte vérification des permissions pour les E/S.Un segment incluant le LDT par défaut partagé par tous les processus3 TLS (Thread Local Storage): pour les applis multithreadésjusqu’à 3 espaces de stockage pour les données locales des threads.3 segments pour l’APM (Advanced Power Management du BIOS)5 segments pour le Plug & Play (service du BIOS)Un segment TSS spécial (exceptions)


Pagination matérielleL’unité de pagination traduit/transforme les adresses linéaires/virtuelles en adresses physiquesPour des raisons d’efficacité, les adresses linéaires sont groupées en intervalles de taille fixe: des pagesDes adresses contigües dans une page se traduisent (généralement) par des adresses physiques contigüesDifférence entre Page manipulée par l’OS et Page physique (page frame/cadre ou page physique)

Une Page peut au cours de l’exécution changer de cadre (en mémoire ou sur le disque)

Les structures de données assurant la conversion des adresses sont des tables de pages

Stockées en mémoire (ou en partie dans le TLB …)Doivent être initialisées par le noyau

Les processeurs Intel peuvent fonctionner sans paginationRegistre pour activation de la pagination(drapeau PG du registre cr0)Si désactivé, adresses linéaire sont interprétées comme physiques


Pagination (80386)L’unité de Pagination des 80386 traite des pages/cadres physiques de 4KBUne adresse linéaire 32 bits est divisée en

Directory (répertoire): 10 bits de poids fortsTable : 10 bits intermédiairesOffset : 12 bits de poids faible

La conversion se fait en 2 étapes, en utilisant le répertoire de pages et la table de pagesLe répertoire de pages contient l’adresse de la table de pagesLa table de pages contient l’adresse des pages physiquesL’adresse physique du répertoire de pages est stockée dans le registre cr3Taille maximale adressable:

10 bits pour le Page Directory donc 210 entrées possiblesDonc 1024x1024x4096=232 cellules mémoire


Pagination (2)


Répertoire Table Offset

Adresse linéaire/virtuelle

01112212231

cr3

+

+

+Répertoire

de page

Table de pages

Pages

Entrées des tablesLes entrées dans les répertoires et tables de pages ont les mêmes structures:

Present : la page ou la table de pages est présente en mémoire20 bits les plus significatifs (poids fort) de l’adresse physique de la page

Les pages sont des multiples de 4096Les 12 bits les moins significatifs sont toujours 0

Accessed : Mis quand l’unité de pagination accède à la page. Remis à 0 par l’OSDirty : Applicable seulement aux entrées de la table de pages (et donc les pages).

Mis à 1 lors de l’écriture sur un cadre. Remis à 0 par l’OSRead/Write : Droits de lecture ou lecture/écritureUser/Supervisor : Privilège requis pour accéder à la page ou à la table de pagesPCD et PWT : contrôle le cache matériel (méthode de gestion)Page Size : applicable seulement aux entrées du répertoire. Si mis, l’entrée correspond à une page physique de 4MB (ou 2 si Physical Address Extension est actif)


Pagination étendueLes pentiums ont introduit la notion de pagination étendue

Permet des pages physiques dont la taille est de 4KB ou 4MBDans ce cas, l’adresse linéaire/virtuelle est divisée en 2 champs

Répertoire: 10 bits les plus significatifsDéplacement : les 22 bits restants

Entrées dans le répertoireDrapeau Page Size mis à 1Les 10 bits de poids fort seulement sont nécessaires (multiples de 4MB)

Les deux paginations peuvent cohabiterUtilisés pour gérer des gros blocs de mémoire contigus


Pagination étendue (2)


Répertoire Offset 0212231

cr3

+

+Répertoire de page

Page de 4MO


Un exemple de pagination normaleLe noyau assigne l’espace virtuelle 0x20000000 à 0x2003ffff à un processus.Les 10 bits de poids fort: 0x080Si l’on veux accéder à la page 0x20021406:

Accès au répertoire de page à l’adresse 0x080Sélection de la case 0x021 de la table des pages, cela nous donnera l’adresse du cadre.Déplacement dans la page d’une taille de 0x406.


Répertoire de pages Table de pages

0x080

0x3ff

0

0

0x3f0x40

0x3ff

Le cache matérielTous les processeurs modernes ont un ou plusieurs (niveaux de) cachesL’unité de gestion de cache est située entre l’unité de pagination et la mémoire physiqueLe cache peut être:

Direct mapped : chaque ligne en mémoire est mise à la même adresse dans le cacheComplètement associatif: chaque ligne en mémoire peut être stockée n’importe ou dans le cache.

N‐way set associative: chaque ligne de mémoire peut être stockée dans N lignes différentes.

2 possibilités lors d’un accès:Cache hit: données présentes dans le cache

Lecture: données transférées vers les registres du CPU (gain de performance)Écriture: 2 possibilités:

Write through: écriture dans le cache ET dans la mémoire (immédiatement)Write back (ou lazy write): écriture dans le cache (et écriture retardée dans la mémoire)

Cache miss: données absentes du cache, la ligne de cache est écrite en mémoire au besoin et les données sont chargées à partir de la mémoire.


Le cache matériel (2)Plusieurs niveau de cache: L1, L2, L3 … la cohérence entre les différents niveau est implémenté matériellement.

Linux ignore le détails des implémentations et suppose qu’il n’y a qu’un seul cache.

Sur les x86, le cache peut être globalement désactivé ou activéDrapeau CD du registre cr0 pour activation/désactivationDrapeau NW pour Write‐through ouWrite‐back

Possibilité d’associer une politique de cache pour chaque cadre mémoire (entrée dans la table)

PCD (Page Cache Disable) cache activé/désactivéPWT (Page Write through) Write‐through ou Write‐back

Linux mets tous les drapeaux à 0 pour toutes les pagesCache activé avec write‐back pour toutes les pages

Un cache spécifique pour la pagination (table de page) est disponibleTranslation Lookaside BufferGarde en cache les adresses linéaires récemment transforméesIl y en à 1 par CPU


Pagination sous Linux4 niveaux / types de tables (Indispensable pour les machines 64 bits)

Page Global DirectoryPage Upper DirectoryPage Middle DirectoryPage Table

Pour les architectures 32 bits: les 2 répertoires intermédiaires sont éliminées (sans extension d’adresse physique sinon 3 répertoires)Sinon l’adresse linéaire est découpée en 4 parties (64 bits).Chaque processus a sa propre Page Global Directory et ses propres tables de pagesQuand un changement de processus intervient, Linux sauvegarde le contenu de cr3 (adresse du PGD) et charge la nouvelle valeur

L’unité de pagination utilise les bonnes tablesSi Linux tourne sur un processeur qui n’a pas 4 niveaux de paginations (Pentium…), le nombre d’entrées de la Page Middle Directory est mis à 1.


Pagination sous Linux (2)


Global Dir Upper Dir Middle Dir


0

cr3

+

+

+Répertoire global de

page

Haut répertoire de pages

Page

Offset Table

+Répertoire de pages moyen +

Table de pages

Organisation physique de la mémoire

Pendant l’initialisation, le noyau « cartographie » la mémoire.Quels intervalles d’adresses physiques sont utilisables par le noyau et lesquels ne le sont pas (utilisés par des périph ou par le BIOS).

Ensemble de cadres réservées (jamais swappés sur le disque):Les cadres indisponibles (pour le noyau)Les cadres contenant le code et les données initialisées du noyau

Le noyau linux est installé à partir de l’adresse 0x00100000 (2ème méga octet) pour quelques mégas.Quelques particularités de l’architecture PC:

Le cadre 0 est utilisé par le BIOS pour stocker la configuration matérielle de la machine.Adresses physiques de 0x000a0000 à 0x000fffff 640KO à 1MO: réservées pour les routines du BIOS et pour mapper la mémoire interne des cartes graphiques ISA.


Organisation physique de la mémoire (2)

Le noyau exécute machine_specific_memory_setup( ) qui construit la carte d’adresses physique (basée sur la liste du BIOS) Exemple d’utilisation de 128 MO de RAM:


Début Fin Type

0x00000000 0x0009ffff Utilisable

0x000f0000 0x000fffff Réservé

0x00100000 0x07feffff Utilisable

0x07ff0000 0x07ff2fff Données ACPI

0x07ff3000 0x07ffffff ACPI NVS

0xffff0000 0xffffffff Réservé

Petite conclusionSegmentation et pagination sont 2 mécanismes permettant d’atteindre le même objectif (parmi d’autres):

Séparer les espaces d’adressage physique des processusLa segmentation assigne un espace linéaire/virtuel différent à chaque processus (plusieurs dimensions)La pagination permet d’associer un espace linéaire/virtuel à différents espaces physiquesLinux préfère la pagination

La gestion des processus est plus facile sur un unique espace linéaire/virtuelLa segmentation n’est pas disponible sur tous les processeurs (RISC)
