Gestione della Memoria Scenario 1 o pi CPU

  • Slides: 21
Download presentation
Gestione della Memoria

Gestione della Memoria

Scenario • 1 o più CPU • Un certo quantitativo di memoria • Una

Scenario • 1 o più CPU • Un certo quantitativo di memoria • Una memoria di massa

Sommario • Gestione della Memoria Virtuale • Protezione

Sommario • Gestione della Memoria Virtuale • Protezione

Una soluzione comune • Spazio degli indirizzi reali • virtual. Byte mem[M]; // dove

Una soluzione comune • Spazio degli indirizzi reali • virtual. Byte mem[M]; // dove M = 512 MB, 1 GB. . . – Diviso in pagine: • byte P[ X ][4096] // X dipende dalla memoria • Spazio degli indirizzi virtuali (1 per processo) • virtual. Byte mem. Pn[N]; // N = 4 GB per intel x 32 – Diviso in pagine: • byte Pn[ 1 MB ][4096]

Ogni processo viene “illuso”. . . • . . di avere a disposizione 4

Ogni processo viene “illuso”. . . • . . di avere a disposizione 4 GB (OS a 32 bit) 0 byte P 1[1 MB][4096] User Space 0 byte P 2[1 MB][4096] User Space 3 GB - 1 System Space 4 GB - 1

Dov’è il trucco?

Dov’è il trucco?

Suddivisione dell’indirizzo Offset (byte all’interno della pagina, da 0 a 4095 = 12 bit)

Suddivisione dell’indirizzo Offset (byte all’interno della pagina, da 0 a 4095 = 12 bit) Numero Pagina (da 0 a 1 MB-1 = 20 bit)

Gli indirizzi di memoria sono virtuali • • Assumiamo di avere un solo processo

Gli indirizzi di memoria sono virtuali • • Assumiamo di avere un solo processo P 1, e di avere 4 GB di memoria fisica. Immaginiamo di poter esaminare il microcodice delle istruzioni macchina – mov AL, indirizzo – mov indirizzo, AL ** LETTURA ** ** SCRITTURA ** . . . AL = mem. P 1[indirizzo]; // lettura. . . oppure. . . mem. P 1[indirizzo] = AL; // scrittura. . . byte& virtual. Byte: : operator[] (long indirizzo) { pagina = indirizzo >> 12; offset = indirizzo % 4096; return P[pagina][offset]; }

Purtroppo. . . • • C’è più di un processo. L’array P può anche

Purtroppo. . . • • C’è più di un processo. L’array P può anche essere più piccolo di 4 GB; Soluzione • Introduzione di una tabella delle “Page Entries”, una per ogni processo. typedef pagina byte[4096]; pagina P[X]; // X dipende dalla memoria RAM reale. class Page. Entry { bool long bool in. Memoria; acceduto; scritto; posizione. Su. Disco; leggibile; scrivibile; eseguibile; } class process {. . Page. Entry page. Directory[1 MB]; virtual. Byte mem(4 GB, page. Directory); }

Il vero operator[] è simile a. . . byte& virtual. Byte: : operator[] (long

Il vero operator[] è simile a. . . byte& virtual. Byte: : operator[] (long indirizzo) { pagina = indirizzo >> 12; offset = indirizzo % 4096; Page. Entry pe = page. Directory[pagina]; if (!pe. in. Memoria) { // page fault. pe. posizione = trova. Pagina. Libera(); load. Page(pe. posizione. Su. Disco); // swap in pe. scritto = false; // pagina fresca presa da disco } pe. acceduto = true; if (operazione di Scrittura) pe. scritto = true; return P[pe. posizione][offset]; }

Swap in e Swap out • Ci sono dei thread ad altissima priorità che

Swap in e Swap out • Ci sono dei thread ad altissima priorità che si occupano di – Caricare in anticipo le pagine che si prevede siano usate (Swap in) – Eliminare le pagine non usate (swap out) • Linux: è il demone kswapd

Swap out • Semplice algoritmo: le pagine stanno in una lista FIFO. Quando una

Swap out • Semplice algoritmo: le pagine stanno in una lista FIFO. Quando una pagina p è acceduta, viene settato il bit p. acceduto a 1, e viene messa in testa alla FIFO. • Un thread “pulitore”, elimina periodicamente dalla fine della coda (swap out) quelle pagine p in cui trova p. acceduto == 0. Pone p. acceduto = 0 per tutte le altre pagine • Le pagine accedute periodicamente tendono ad evitare di essere “swapped out”. • Eccezioni: pagine marcate come inamovibili, working set • Algoritmo reale. . un po’ più complicato. • Il “pulitore” è tanto più aggressivo tanto più c’è meno memoria.

Swap out void swapout(Page. Entry p) { if (p. scritto) p. posizione. Su. Disco

Swap out void swapout(Page. Entry p) { if (p. scritto) p. posizione. Su. Disco =scrivi. Su. Disco(p. posizione); p. in. Memoria = false; }

Windows Memory Lifecycle

Windows Memory Lifecycle

Thrashing Ipotesi: Thread tutti uguali: occupazione 128 MB, 25% occupazione media processore Memoria centrale:

Thrashing Ipotesi: Thread tutti uguali: occupazione 128 MB, 25% occupazione media processore Memoria centrale: 512 MB

Protezione • E’ fisicamente impossibile (o quasi) che un processo acceda alla memoria di

Protezione • E’ fisicamente impossibile (o quasi) che un processo acceda alla memoria di un altro P 2 P 1 P 0 0 0 1 GB - 1 0 3 GB - 1 System Space 4 GB - 1 System Space Image User Space 0 Mem Reale User Space 3 GB - 1 0 Swap File Swapped Out System Pages 1 GB - 1 4 GB - 1

Protezione – 2 • I processi tuttavia condividono lo stesso system space – Ci

Protezione – 2 • I processi tuttavia condividono lo stesso system space – Ci sono pagine fisiche riferite da page entries di più processi – L’accesso in lettura/scrittura può essere proibito tramite i valori di p. leggibile e p. scrivibile – Si può proibire anche l’eseguibilità (DEP: Data execution prevention)

Loading e rilocazione 004010 CA 004010 D 0 004010 D 5 004010 D 7

Loading e rilocazione 004010 CA 004010 D 0 004010 D 5 004010 D 7 004010 D 8 004010 DA 8 B A 1 F 7 4 B 75 A 3 1 D 50 8 D 42 00 D 0 99 42 00 E 3 FB D 0 99 42 00 11111011 = -5 Codice indipendente dalla posizione mov mul dec jne mov ebx, dword ptr [a (00428 d 50)] eax, [b (004299 d 0)] eax, ebx ciclo (004010 d 5) [b (004299 d 0)], eax

Codice non rilocabile 004010 EA 004010 EF 004010 F 4 004010 F 6 00401005

Codice non rilocabile 004010 EA 004010 EF 004010 F 4 004010 F 6 00401005 0040100 A 0040100 F 00401014 00401019 B 9 E 8 8 B E 8 E 9 E 9 E 9 E 0 99 42 00 8 C 01 00 00 C 8 0 A FF FF FF 36 E 1 8 C 27 22 01 01 01 00 02 00 00 00 mov call jmp jmp jmp ecx, offset cout (004299 e 0) ostream: : operator<< (00401280) ecx, eax @IAT+0(ostream: : operator<<) (00401005) ostream: : operator<< (00401140) ostream: : operator<< (004011 f 0) endl (004011 a 0) main (00401040) flush (00401240) ASLR Address space layout randomization

PE : Portable Executable

PE : Portable Executable

Mobile OSes • Android: cambio di paradigma – No swap space – Un processo

Mobile OSes • Android: cambio di paradigma – No swap space – Un processo può essere killed per poter liberare memoria – OOM Manager (Out of Memory Manager) diventa modulo cruciale