the big picture gestione della memoria (2)...

Operating Systems and Distributed Systems

Gestione della Memoria (2)


The big picture

Processaddressspace

Augmentingaddressspace

Memoryorganization(allocation)

HW support

Contiguousallocation

Non contiguousallocation

Fixeddimension

Variabledimension

Segmentation

Paging

Paging &Segmentation

Fixed partitioning

Variable partitioning

Limit &relocation registers

Dedicatedregisters

TLBPage table

Segment table

Swappig

Virtual Memory

Page request

Page replacement

Frame allocation

Table basedpartitioning

Dynamicallocation

2


Paging (paginazione)• Spazio di indirizzamento logico del processo non contiguo;

• Si divide la memoria fisica in blocchi di dimensione fissa, chiamati frame o pagine fisiche (la dimensione è una potenza del 2, compresa fra 512 byte e 16 MB, ma valori tipici negli elaboratori attuali sono 4KB!8KB)

• Si divide la memoria logica in blocchi della stessa dimensione, chiamati pagine

• Si tiene traccia di tutti i frame liberi

• Per eseguire un programma di dimensione n pagine, è necessario trovare n frame liberi prima di caricare il programma

• y = Bt(x) : Si impiega una tabella delle pagine per tradurre gli indirizzi logici negli indirizzi fisici corrispondenti

• Solo frammentazione interna (relativa all’ultimo frame)

3 Operating Systems and Distributed Systems

Schema di traduzione degli indirizzi• L’indirizzo generato dalla CPU viene suddiviso in:

– Numero di pagina (p)• impiegato come indice in una tabella di pagine che contiene

l’indirizzo base di ciascun frame nella memoria fisica

– Offset nella pagina (d)• combinato con l’indirizzo base per definire l’indirizzo fisico

di memoria che viene inviato all’unità di memoria

Numero di pagina offset

p d

m ! n n

Spazio logico di 2m indirizzi con 2m-n pagine

di dimensione 2n


• 4 KB (=4096 byte) dimensione pagina• indirizzi logici a 32 bit (m=32)

p d

2n = 4096 n = 12

12 bits

indirizzo logico di 32 bit

g=m-n=32-12 = 20 bits

Schema di traduzione degli indirizzi:esempio

//------------------------------------------------------------------

----//

// MemoryTranslateUserToSystem//

//!Translate a user address (in the process referenced by pcb)//!into an OS (physical) address. This works for simple one-level

//!page tables, but will have to be modified for two-level page//!tables.

////------------------------------------------------------------------

----uint32 MemoryTranslateUserToSystem (PCB *pcb, uint32 addr)

{ int! page = addr / MEMORY_PAGE_SIZE;

int offset = addr % MEMORY_PAGE_SIZE;

if (page > pcb->npages) { return (0);

} return ((pcb->pagetable[page] & MEMORY_PTE_MASK) + offset);

}


Traduzione dell’indirizzo

6

• numero pagina

• offset nella pagina


Esempi di paginazioneModello di paginazione di memoria logica e memoria fisica

Memoria da 32 byte con pagine da 4 byte

ESEMPIO: 6 = 00110 !

#pagina=1, offset=2 !

6"4+2 = 26


Tabella dei frame• Poiché il SO gestisce la memoria fisica, deve essere

informato su:– quali frame sono assegnati

– quali e quanti frame sono liberi

• …

• Le informazioni sono contenute nella tabella dei frame

– Una entry per ciascun frame, per definire se la pagina fisica è libera o assegnata e, nel secondo caso, a quale pagina di quale(/i) processo(/i)


0–4K4–8K8–12K12–16K16–20K20–24K24–28K28–32K

Riassumendo....

– Se la pagina i è caricata al page frame j, l’indirizzo virtuale è rilocato al page frame j

– se la pagina non è caricata (page fault), il SO interrompe il processo e carica la pagina nel page frame

70–4K44–8K

8–12K12–16K

016–20K20–24K24–28K

328–32K32–36K36–40K

140–44K544–48K648–52K-52–56K

56–60K-60–64K

Virtual

address

space

Physical

memory

-

--

--

--


Implementazione delle tabelle (vista software)

typedef struct {

unsigned int frame:22;

unsigned int bit : 1; /* 1 => frame is valid */

unsigned int dirty: 1; /* 1 => frame has been updated; needs writing */

unsigned int ref : 1; /* 1 => the page has been referenced */

int cnt; /* how many references */

int first_time; /* swap-in time for page */

int last_time; /* last time referenced */

} page_entry;

typedef struct {

page_entry entries[MAXPAGES];

} page_table;

typedef struct {

int page;

} frame_entry;

typedef struct {

frame_entry entries[MAXFRAMES];

} frame_table;

page_table *PTBR;

frame_table *FTBR;


Cosa c’è in una page table entry?– Valid bit: 1 se logical page number ha un corrispondente

physical frame in memoria– Page frame number: pagina nella memoria fisica– Referenced (Used) bit: 1 se la pagina è stata utilizzata– Dirty (modified) bit : 1 se la pagina è stata modified– Informazione di protezione

Page frame numberVRDProtection

Valid bitReferenced

or Used bit

Dirty bit


Protezione della memoria ! 1• La protezione della memoria è implementata associando uno

o più bit di protezione a ciascun frame nella tabella delle pagine

– I bit determinano se una certa pagina può essere acceduta in lettura, scrittura e/o esecuzione

• Tutti i riferimenti alla memoria passano attraverso la tabella delle pagine

– Mentre si effettua il mapping da indirizzi logici ad indirizzi fisici, si verificano le modalità di accesso al dato frame

– Un tentativo di accesso che viola quanto codificato nei bit di protezione provoca una trap al SO



Protezione della memoria ! 2• Un ulteriore bit di validità viene associato ad ogni elemento

della tabella delle pagine:

– Un valore “valido” indica che la pagina è nello spazio degli indirizzi logici del processo, e quindi è una pagina legale

– Un valore “non valido” indica che la pagina non si trova nello spazio di indirizzi logici del processo

• Il bit di validità consente di riconoscere gli indirizzi illegali e di notificare l’anomalia con un segnale di eccezione

• È il sistema operativo che concede o revoca il diritto di accesso ad una data pagina, impostando opportunamente il bit di validità



Processaddressspace



HW support



Fixeddimension

Variabledimension

Segmentation

Paging


Fixed partitioning



Dedicatedregisters

TLBPage table

Segment table

Swappig

Virtual Memory

Page request

Page replacement

Frame allocation


Dynamicallocation

14

Schema generale

Operating Systems and Distributed Systems 15

page number

p d

page offset

(=line)

0

1

p-1

p

p+1

f

f d

Page frame number

.

.

.

page table

physical memory

0

1

.

.

.

f-1

f

f+1

f+2

.

.

.

Page frame number

CPU

Supporto hardware alla paginazione


Implementazione della tabella delle pagine

• La tabella delle pagine risiede in memoria centrale; si ha una tabella per ogni processo

• Il registro Page!Table Base Register (PTBR) punta all’inizio della tabella

• Il registro Page!Table Length Register (PTLR) indica la dimensione della tabella

• Con questo schema, ogni accesso a dati o istruzioni richiede di fatto due accessi alla memoria: uno per la tabella e uno per le istruzioni/dati

• Il problema dei due accessi alla memoria può essere risolto per mezzo dei registri associativi (altrimenti detti translation look–aside buffer, TLB) attraverso i quali si effettua una ricerca parallela veloce su una piccola tabella (64!1024 elementi)


Processaddressspace



HW support



Fixeddimension

Variabledimension

Segmentation

Paging


Fixed partitioning



Dedicatedregisters

TLBPage table

Segment table

Swappig

Virtual Memory

Page request

Page replacement

Frame allocation


Dynamicallocation

17

Schema generale


TLB• Memoria associativa ! ricerca parallela

• " Traduzione dell’indirizzo (p, d)• Se p è nel registro associativo, si reperisce il

numero del frame

• Altrimenti, si recupera il numero di frame dalla tabella delle pagine in memoria

# Pagina # Frame


Supporto hw per la tabella delle pagine


Gestione dei TLB misses

• Se PTE non è in TLB, il SO effettua il lookup nella page table– hardware o software

• Hardware TLB replacement– CPU fa il page table lookup– Più veloce che via software

– meno flessibile e hardware più complesso

• Software TLB replacement– SO riceve TLB exception– Exception handler fa page table lookup & scrive il risultato in TLB– Programma continua dopo il return from exception

– TLB capaci (basso miss rate) lo rendono possibile


Memoria condivisa• Codice condiviso

– Una copia di codice di sola lettura viene condivisa fra processi (ad es.: text editor, compilatori, sistemi a finestre)

– Il codice condiviso deve apparire nella stessa locazione nello spazio degli indirizzi logici di tutti i processi

• Codice e dati privati – Ciascun processo mantiene una copia separata

dei dati e del codice

– Le pagine di codice e dati privati possono apparire ovunque nello spazio degli indirizzi


Esempio: pagine condivise

Condivisione di codice in un ambiente di paginazione: editor contenuto in tre pagine


Struttura della tabella delle pagine

• Paginazione gerarchica

• Tabella delle pagine hash

• Tabella delle pagine invertita


• Quando lo spazio degli indirizzi logici è grande, la stessa tabella delle pagine viene paginata

• Esempio: paginazione a due livelli

Struttura della tabella delle pagine: gerarchica

884

960

955

.

.

.

220

657

401

.

.

.

1st level

page table

2nd level

page tables

...

...

...

...

...

...

...

...

...

main

memory

.

.

.

125

613

961

.

.

.


Struttura della tabella delle pagine: gerarchica

25

.

.

.

.

.

.

p1 = 10 bits p2 = 9 bits offset = 13 bits

page offsetpage number

.

.

.

0

1

p1

.

.

.

0

1

p2

19

physical address

1st level page table

2nd level page table

main memory

0

1

frame

number

13Pagetablebase

.

.

.

.

.

.


• I numeri di pagina virtuale vengono confrontati con tutti gli elementi della catena

– A fronte di una ricerca positiva, si estrae il corrispondente numero di frame

Struttura della tabella delle pagine: hashing


pid1

pidk

pid0

process ID p = 19 bits offset = 13 bits

page number

1319

physical address

inverted page table

main memory

.

.

.

0

1

.

.

.

Page frame

number

page offset

pid p

p0

p1

pk

.

.

.

.

.

.

0

1

k

search

k

Struttura della tabella delle pagine: inversione


Processaddressspace



HW support



Fixeddimension

Variabledimension

Segmentation

Paging


Fixed partitioning



Dedicatedregisters

TLBPage table

Segment table

Swappig

Virtual Memory

Page request

Page replacement

Frame allocation


Dynamicallocation

Schema generale


Segmentazione

– Schema di gestione della memoria che asseconda la visione utente (l’utente generalmente non pensa alla memoria come ad un array lineare di byte)

– Un programma è una collezione di segmenti; un segmento è un’unità logica

Operating Systems and Distributed Systems30

• Ciascun segmento ha lunghezza variabile, definita intrinsecamente dal compito svolto dal segmento

• Gli elementi, all’interno di un segmento, sono identificati mediante il loro offset dall’inizio del segmento

• Ogni indirizzo è rappresentato da una coppia ordinata di valori <numero_di_segmento, offset >

Symbol

table

0K

4K

8K

12K

16K

20K

Segment 0

Source

text

0K

4K

8K

12K

16K

Segment 1

Constants

0K

4K

8K

Segment 2

Call

stack

0K

4K

8K

12K

Segment 3

Segmentazione


Segmentazione: Schema logico

1

3

2

4

1

4

2

3

Spazio utente Spazio fisico di memoria


Modello di traduzione

• Bt: segments x offsets # physical address $ {%}

• Bt(i, j) = k

• S: segments # segment addresses

• Bt(S(segName), j) = k

• N: offset names # offset addresses

• Bt(S(segName), N(offsetName)) = k


Esempi:

<2,53> = 4353

<3,852> = 4052

<0,1222> = TRAP


Processaddressspace



HW support



Fixeddimension

Variabledimension

Segmentation

Paging


Fixed partitioning



Dedicatedregisters

TLBPage table

Segment table

Swappig

Virtual Memory

Page request

Page replacement

Frame allocation


Dynamicallocation

Schema generale


Segmentazione: supporto HW• Tabella dei segmenti ! mappa gli indirizzi fisici bidimensionali; ciascun

elemento della tabella contiene:

– base ! indirizzo fisico iniziale della memoria contenente il segmento

– limite ! specifica la lunghezza del segmento

• Il registro Segment!Table Base Register (STBR) punta alla locazione in memoria della tabella dei segmenti

• Il registro Segment!Table Length Register (STLR) indica il numero di segmenti utilizzati dal programma; un numero di segmento s è legale se s < STLR

• Protezione: Si associa a ciascun elemento della tabella dei segmenti:

– bit di validità = 0 -> segmento illegale

– privilegi read/write/execute

• La condivisione di codice viene implementata a livello di segmento

• Dato che i segmenti variano di dimensione, l’allocazione della memoria è un problema di allocazione dinamica


Segmentazione: supporto HW


Segmentazione & paginazione:l’esempio Pentium

• Supporta sia la segmentazione pura che la segmentazione mista a paginazione


Intel Pentium Segmentation Unit

– Segment selector per identificare il descriptor

– Segmento puntato dal segment descriptor

– Segment descriptor

descrive il segmento

• Segment descriptor:– Base virtual address

– Size

– Protection

– Code / data


Pentium Paging Architecture•Pentium has 6 segment

registers

CS, SS, DS, ES, FS, GS

•Also has 6 microprogram

registers to hold the associated

segment descriptor to avoid

memory refs on each

translation.

•A segment register holds a

segment "selector"

•A selector is 16 bits and uses

13 to hold the segment index

(s), 1 bit for the gdt/ldt switch

(g), and 2 bits for the privilege

level (p).

•The gdt/ldt switch is used to

select between the GDT (one

for the entire system and

shared between all processes)

and the LDT (private to the

process)

•Given the table, use (s) to

index into the table.


Processaddressspace



HW support



Fixeddimension

Variabledimension

Segmentation

Paging


Fixed partitioning



Dedicatedregisters

TLBPage table

Segment table

Swappig

Virtual Memory

Page request

Page replacement

Frame allocation


Dynamicallocation

Schema generale


Swapping

• Supportata da dynamic memory allocation

• La Memory allocation cambia quando: – Processi entrano in memoria

– Processi lasciano la memoria• Swapped to disk

• Esecuzione completata

•

OS OS OS OS OS OS OS

A A

B

A

B

C

B

C

B

C

D

C

D

C

D

A

swap-out swap-in


Limiti dello swapping puro• Problemi

– Processi devono poter essere allocati nella memoria fisica

– Frammentazione• External fragmentation

• Necessario il compattamento

– Processi: o memoria o disco


The big picture

Processaddressspace



HW support



Fixeddimension

Variabledimension

Segmentation

Paging


Fixed partitioning



Dedicatedregisters

TLBPage table

Segment table

Swappig

Virtual Memory

Page request

Page replacement

Frame allocation


Dynamicallocation


Memoria virtuale• Separazione della memoria logica dell’utente dalla memoria

fisica

– Solo parte del programma deve trovarsi in memoria per l’esecuzione

– Lo spazio logico degli indirizzi può essere molto più grande dello spazio fisico

– Porzioni di spazio fisico possono essere condivise da più processi

– Creazione di nuovi processi più efficiente

• La memoria virtuale può essere implementata per mezzo di:

– Paginazione su richiesta

– Segmentazione su richiesta


• Ogni processo ha code e data locality

– Codice eseguito in poche “porzioni” per volta– Riferimento allo stesso set di strutture dati

– Da un esame dei programmi reali risulta che non è sempre necessaria la presenza in memoria dell’intero programma; per esempio…

• Porzioni di codice relative a gestione di condizioni di errore insolite o percorsi nel flusso raramente seguiti

• Array, liste e tabelle sovradimensionati rispetto all’utilizzo reale

– Anche nei casi in cui tutto il programma deve risiedere completamente in memoria è possibile che non serva tutto in una volta

Memoria virtuale: località


• Vantaggi della presenza di “porzioni” di programmi in memoria:– I programmi non sono più vincolati alla quantità di

memoria fisica disponibile

– Poiché ogni programma impiega meno memoria fisica, aumenta il grado di multiprogrammazione e la produttività della CPU, senza aumentare il tempo di risposta o di turnaround

– Per caricare/scaricare ogni programma in memoria è necessario un minor numero di operazioni di I/O

• Aumentano le prestazioni del sistema

Memoria virtuale


• Separazione memoria virtuale/memoria fisica – Memoria virtuale molto più ampia della memoria fisica

Memoria virtuale



Memoria virtuale

Programma D

Memoria

0000x Programma A-1

Programma B-1

Programma A-2

Programma A-3

Programma B-2

Swap



Memoria virtuale

Programma D

Memoria

0000x Programma A-2

Programma B-1

Programma A-1

Programma A-3

Programma B-2

Swap


Memoria virtuale: condivisione• Il “buco” che separa lo heap dalla pila è parte dello spazio degli indirizzi

virtuali del processo, ma si richiede l’allocazione di pagine fisiche solo se viene progressivamente “riempito”

– Uno spazio virtuale contenente buchi si definisce sparso

– Utile non solo per le possibili espansioni di heap e stack ma anche per il collegamento dinamico di librerie (o codice condiviso) durante l’esecuzione del programma


Memoria virtuale: condivisione

• La memoria virtuale facilita la condivisione di file e memoria, mediante condivisione delle pagine fisiche

– Le librerie di sistema sono condivisibili mediante mappatura

• Ogni processo vede le librerie come parte del proprio spazio di indirizzi virtuali, ma le pagine che le ospitano effettivamente nella memoria fisica ! accessibili in sola lettura ! sono in condivisione fra tutti i processi che utilizzano le librerie

– Mediante la condivisione delle pagine in fase di creazione, i nuovi processi possono essere generati più rapidamente


Processaddressspace



HW support



Fixeddimension

Variabledimension

Segmentation

Paging


Fixed partitioning



Dedicatedregisters

TLBPage table

Segment table

Swappig

Virtual Memory

Page request

Page replacement

Frame allocation


Dynamicallocation

Schema generale


Paginazione su richiesta (Demand Paging)

• Swapper pigro ! Si sposta una pagina in memoria solo quando è necessaria:– Occorrono meno operazioni di I/O

– Viene impiegata meno memoria– Si ha una risposta più veloce– Si possono gestire più utenti

• Richiesta di una pagina -> si fa un riferimento alla pagina– Riferimento non valido -> abort

– Pagina non in memoria -> trasferimento in memoria

• Il modulo del SO che si occupa della paginazione su richiesta è il pager



Swapper tradizionale in un sistema pag inato con avv icendamento: trasferimento di una memoria paginata nello spazio contiguo di un disco

• il pager ipotizza quali pagine saranno utilizzate prima che il processo venga nuovamente scaricato dalla memoria

• trasferisce in memoria solo le pagine necessarie

• meccanismo per distinguere le pagine presenti in memoria da quelle su disco

• bit di validità presente nella tabella delle pagine


• Bit di validità: – v -> pagina in memoria

– i -> pagina non valida o non residente in memoria

• Inizialmente il bit di validità viene posto ad “i” per tutte le pagine

• In fase di traduzione degli indirizzi, se il bit di validità vale “i”– si verifica un page fault


v

v

v

v

i

i

i

….

#Frame bit di validità

tabella delle pagine



Istantanea di una tabella delle pagine con pagine non allocate in memoria principale


Page fault• Il primo riferimento ad una pagina causa una

trap al sistema operativo -> page fault

• Il SO consulta una tabella interna delle pagine (conservata con il PCB) per decidere se si tratta di…– riferimento non valido

• abort

– pagina non in memoria• Seleziona un frame vuoto

• Sposta la pagina nel frame • Aggiorna le tabelle delle pagine (bit di validità = v)• Riavvia l’istruzione che era stata interrotta


Page fault

Fasi di gestione di un’eccezione di pagina mancante


Creazione di processi e memoria virtuale

! Due vantaggi:

" - Copy-on-Write

" - Memory-Mapped Files (più avanti)


Copy-on-Write (COW)

• permette alla coppia di processi padre!figlio di condividere, inizialmente, le stesse pagine di memoria

• Se uno dei due processi modifica una pagina condivisa, e solo in quel caso, viene creata una copia della pagina

• COW garantisce una modalità di creazione dei processi più efficiente, grazie alla copia delle sole pagine (condivise) modificate

• L’allocazione delle nuove pagine per effetto di un’operazione di copia avviene mediante una tecnica nota come azzeramento su richiesta

– Prima dell’allocazione, il contenuto delle pagine viene azzerato


Copy-on-Write (COW)

Prima della modifica della pagina C da parte del processo1


Copy-on-Write (COW)

Dopo la modifica della pagina C da parte del processo1 page Copy_C

Dopo la modifica della pagina C da parte del processo1


Processaddressspace



HW support



Fixeddimension

Variabledimension

Segmentation

Paging


Fixed partitioning



Dedicatedregisters

TLBPage table

Segment table

Swappig

Virtual Memory

Page request

Page replacement

Frame allocation


Dynamicallocation

Schema generale


Cosa accade quando non ci sono frame liberi ?

• Sostituzione di pagina ! si trova una pagina in memoria che non risulti attualmente utilizzata e si sposta sul disco– Scelta di un algoritmo di selezione– Prestazioni: è richiesto un metodo che produca

il minimo numero di page fault

• La stessa pagina può essere riportata in memoria più volte


Sostituzione delle pagine 1. Individuazione della pagina richiesta su disco

2. Individuazione di un frame libero:

A. Se esiste un frame libero, viene utilizzato

B. Altrimenti viene utilizzato un algoritmo di sostituzione per selezionare un frame vittima

C. La pagina vittima viene scritta sul disco; le tabelle delle pagine e dei frame vengono modificate conformemente

3. Lettura della pagina richiesta nel frame appena liberato; modifica delle tabelle delle pagine e dei frame

4. Riavvio del processo utente


Sostituzione delle pagine


Algoritmi di sostituzione delle pagine • minimizzare la frequenza di page faul

• Si valutano gli algoritmi eseguendoli su una particolare stringa di riferimenti a memoria (reference string ) e contando il numero di page fault su tale stringa


Random Replacement• y scelta fra m frame con probabilità 1/m

R = 2031203120316457

Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7

0

1

2

2

1

3

2

1

3

2

1

0

3

1

0

3

1

0

3

1

2

0

1

2

0

3

2

0

3

2

0

6

2

4

6

2

4

5

2

7

5

2

2

0

3

2

0

2

• Nessuna conoscenza di R & scarsa performance

• Facile da implementare

13 page faults


R = 2031203120316457

Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7

0 2 2 2

1 0 0

2 3

AGE4(2) = 3

AGE4(0) = 2

AGE4(3) = 1

First In First Out (FIFO)

• Sostituisci pagina da più tempo in memoria yt = max x"St-1(m) AGE(x)


Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7

0 2 2 2 1

1 0 0 0

2 3 3

AGE4(2) = 3

AGE4(0) = 2

AGE4(3) = 1


R = 2031203120316457



Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7

0 2 2 2 1

1 0 0 0

2 3 3

AGE5(1) = ?

AGE5(0) = ?

AGE5(3) = ?


R = 2031203120316457



Algoritmo ottimo di Belady • Sostituire la pagina che non verrà usata per il periodo

di tempo più lungo (forward distance):

• yt = max x"St-1(m)FWDt(x) R = 2031203120316457

Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7

0 2 2 2

1 0 0

2 3


Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7

0 2 2 2

1 0 0

2 3

FWD4(2) = 1

FWD4(0) = 2

FWD4(3) = 3

• Sostituire la pagina che non verrà usata per il periodo di tempo più lungo (forward distance):


Algoritmo ottimo di Belady


Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7

0 2 2 2 2

1 0 0 0

2 3 1

FWD4(2) = 1

FWD4(0) = 2

FWD4(3) = 3





Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7

0 2 2 2 2 2 2

1 0 0 0 0 0

2 3 1 1 1





Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7

0 2 2 2 2 2 2 2

1 0 0 0 0 0 3

2 3 1 1 1 1

FWD7(2) = 2

FWD7(0) = 3

FWD7(1) = 1





Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7

0 2 2 2 2 2 2 2 2 2 0

1 0 0 0 0 0 3 3 3 3

2 3 1 1 1 1 1 1 1

FWD10(2) = '

FWD10(3) = 2

FWD10(1) = 3





Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7

0 2 2 2 2 2 2 2 2 2 0 0 0

1 0 0 0 0 0 3 3 3 3 3 3

2 3 1 1 1 1 1 1 1 1 1

FWD13(0) = '

FWD13(3) = '

FWD13(1) = '





• Conoscenza di R & performance ottima

• Impossibile da implementare: si approssima

10 page faults

Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7

0 2 2 2 2 2 2 2 2 2 0 0 0 0 4 4 4

1 0 0 0 0 0 3 3 3 3 3 3 6 6 6 7

2 3 1 1 1 1 1 1 1 1 1 1 1 5 5





Least Recently Used (LRU)

• Pagina che non è stata usata da più tempo (max backward distance): yt = max x"St-1(m) BKWDt(x)

R = 2031203120316457

Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7

0 2 2 2

1 0 0

2 3

BKWD4(2) = 3

BKWD4(0) = 2

BKWD4(3) = 1


Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7

0 2 2 2 1

1 0 0 0

2 3 3

BKWD4(2) = 3

BKWD4(0) = 2

BKWD4(3) = 1



R = 2031203120316457


Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7

0 2 2 2 1 1

1 0 0 0 2

2 3 3 3

BKWD5(1) = 1

BKWD5(0) = 3

BKWD5(3) = 2



R = 2031203120316457


Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7

0 2 2 2 1 1 1

1 0 0 0 2 2

2 3 3 3 0

BKWD6(1) = 2

BKWD6(2) = 1

BKWD6(3) = 3



R = 2031203120316457


Frame 2 0 3 1 2 0 3 1 2 0 3 1 6 4 5 7

0 2 2 2 1 1 1 3 3 3 0 0 0 6 6 6 7

1 0 0 0 2 2 2 1 1 1 3 3 3 4 4 4

2 3 3 3 0 0 0 2 2 2 1 1 1 5 5

• Buon predittore della forward distance --

principio di località



R = 2031203120316457


• Varie implementazioni:– a stack– seconda chance

– seconda chance migliorato–



Confronto fra metodi

If graph omits faults that occur before all the page frames have been filled,that is, it ignores the first f faults when there are f page frames we are measuring the warm-start behavior of the replacement policy instead of the cold-start behavior.


Anomalia di Belady

• FIFO con m = 3 ha 9 faults

• FIFO con m = 4 ha 10 faults

R = 012301401234

Frame 0 1 2 3 0 1 4 0 1 2 3 4

0 0 0 0 3 3 3 4 4 4 4 4 4

1 1 1 1 0 0 0 0 0 2 2 2

2 2 2 2 1 1 1 1 1 3 3

Frame 0 1 2 3 0 1 4 0 1 2 3 4

0 0 0 0 0 0 0 4 4 4 4 3 3

1 1 1 1 1 1 1 0 0 0 0 4

2 2 2 2 2 2 2 1 1 1 1

3 3 3 3 3 3 3 2 2 2


Anomalia di Belady


Processaddressspace



HW support



Fixeddimension

Variabledimension

Segmentation

Paging


Fixed partitioning



Dedicatedregisters

TLBPage table

Segment table

Swappig

Virtual Memory

Page request

Page replacement

Frame allocation


Dynamicallocation

Schema generale


Allocazione dei frame

• Ciascun processo richiede un numero minimo di pagine fisiche– Il numero minimo di frame necessari per ogni

processo è definito dall’architettura, il massimo dalla disponibilità di memoria

–


Allocazione statica

Allocazione uniforme ( Per esempio, se si hanno a disposizione

100 frame per 5 processi, si assegnano 20 pagine a ciascun processo

Allocazione proporzionale ( Si allocano frame sulla base della

dimensione del processo

si = dimensione del processo pi (in frame)

S = ) si

m = numero complessivo dei frame

ai = allocazione per il processo pi = (si/S)"m

ESEMPIO

m = 64

s1=10

s2=127

a1=(10/137)"64*5

a2=(127/137)"64*59


Allocazione con priorità

• Si impiega uno schema di allocazione proporzionale in base alla priorità piuttosto che alla dimensione– Se il processo Pi genera un page fault…

• Si seleziona per la sostituzione uno dei suoi frame (local)

• Si seleziona per la sostituzione un frame di un processo con valore di priorità più basso (global)


Local vs. global

• Sostituzione globale ! il processo seleziona il frame da sostituire dall’insieme di tutti i frame; il processo può selezionare un frame di un altro processo

– Un processo non può controllare la propria frequenza di page fault

• Sostituzione locale ! ciascun processo seleziona i frame solo dal proprio insieme di frame allocati

– Non rende disponibili a processi che ne facciano richiesta pagine di altri processi scarsamente utilizzate

• La sostituzione globale garantisce maggior throughput

• Più utilizzata nei SO più diffusi


Thrashing

• Se un processo non ha abbastanza pagine fisiche a disposizione, la frequenza di page fault è molto alta– Basso impiego della CPU– Il SO crede di dover aumentare il grado di

multiprogrammazione

– si aggiunge un altro processo al sistema!

• Thrashing # un processo è costantemente occupato a spostare pagine dal disco alla memoria e viceversa


Thrashing

La paginazione degenera ! trashing


Paginazione su richiesta e thrashing

• Perché la paginazione su richiesta funziona?– Principio di località:

• Una località è un insieme di pagine che vengono accedute insieme ! che sono contemporaneamente in uso attivo

– Il processo passa da una località ad un’altra– Le località possono essere sovrapposte

• Perché avviene il thrashing?– " !(dim. località) > dim. memoria totale


File mappati in memoria

• L’I/O su file mappati in memoria fa sì che si tratti l’I/O su file come un normale accesso alla memoria– Si realizza associando un blocco del disco ad una o più

pagine residenti in memoria

• L’accesso iniziale al file avviene tramite una normale richiesta di paginazione– Una porzione del file, pari ad una pagina, viene caricata

dal sistema in una pagina fisica

– Ogni successiva lettura e scrittura del file viene gestita come un accesso ordinario alla memoria


File mappati in memoria– Semplifica l’accesso a file perché ne permette la

manipolazione attraverso la memoria invece di appesantire il sistema con system call read() e write()


File mappati in memoria– Permette a più processi di mappare

contemporaneamente lo stesso file, garantendo la condivisione di pagine di memoria


Allocazione di memoria del kernel

• Il kernel, per allocare la propria memoria, attinge ad una riserva di memoria libera diversa dalla lista usata per soddisfare i processi utente– Il kernel richiede memoria per strutture dati

dalle dimensioni variabili – Parti della memoria del kernel devono essere

contigue

the big picture gestione della memoria (2)...

Documents