Memoria virtuale
La memoria virtuale è una tecnica che consente di eseguire dei processi, anche se essi non sono completamente contenuti in memoria. Questa tecnica si basa sulla separazione tra memoria logica (quella vista dall'utente) e memoria fisica (quella che in realtà è utilizzata dal processore).
Dall'analisi di come i programmi vengono eseguiti, ci si rende conto che non è necessario caricare tutto il programma in memoria nel momento in cui viene attivato, ma è sufficiente caricare in memoria principale solo la parte che si sta eseguendo. In questo modo la dimensione di un programma non è più vincolata dalla dimensione della memoria principale. Inoltre è possibile eseguire molti più processi in modo sincrono. Un altro aspetto positivo è che il caricamento del programma risulta essere molto più veloce.
Nel momento in cui viene caricato un processo si lasciano dei buchi per consentire al processo stesso di espandersi in caso di chiamate a funzioni oppure in caso di collegamento con librerie esterne. Uno spazio di indirizzamento organizzato in questo modo è detto sparso.
Grazie alla tecnica della memoria virtuale è anche possibile condividere parti di memoria tra più processi separati. In questo modo si hanno numerosi vantaggi:
-grazie ad un'opportuna mappatura, è possibile caricare una volta soltanto librerie di sistema molto usate.
-è possibile creare una regione di memoria completamente accessibile da un altro processo.
-è possibile creare processi più velocemente, con chiamate come fork(), in quanto non è necessario duplicare lo spazio di indirizzamento al momento della chiamata della funzione, ma solo nel momento in cui viene modificata da uno dei processi (padre o figlio) la memoria condivisa.
Paginazione su richiesta
Il concetto della memoria virtuale può avere numerose applicazioni. Una di queste è la paginazione su richiesta, che consente di non caricare in memoria tutto il codice di un programma all'avvio del processo, ma consente di caricare in memoria solo le pagine necessarie per l'esecuzione della prima parte del programma (lazy swapping).
Il pager si occupa di caricare le pagine corrette durante l'esecuzione del programma. E' compito del pager prevedere quali pagine verranno utilizzate dal processo (precariamente), in modo da evitare lunghi tempi di accesso alla memoria secondaria.
Per rendere possibile il lavoro del pager, è necessario un meccanismo basato su bit di parità, che permetta al pager di capire quali pagine siano presenti in memoria principale e quali in memoria secondaria. Il bit di parità indica:
-1, la pagina è accessibile
-0, la pagina non è accessibile (si trova in memoria secondaria oppure non è nello spazio di indirizzamento del processo)
Nel momento in cui viene trovato il bit di parità a 0, si scatena una trap di sistema (page fault), che ha lo scopo di controllare una tabella in cui sono memorizzate le pagine accessibili dal processo. Se il riferimento non è ancora valido il processo viene terminato, altrimenti si carica la pagina richiesta dalla memoria secondaria alla memoria principale. Nel momento in cui l'operazione di inserimento è completata si modifica la tabella dei codici di parità e si riavvia l'esecuzione del processo da dove era stata sospesa.
La paginazione su richiesta pura esegue questo meccanismo in maniera completa (all'avvio il processo non ha pagine caricate in memoria).
La paginazione su richiesta è attuabile solo se si hanno a disposizione alcuni dispositivi hardware:
-tabella delle pagine, per contenere i bit di parità.
-memoria secondaria, in cui sono conservate le pagine non presenti in memoria centrale. Essa è costituita da un disco ad alta velocità con un'area riservata alla paginazione (area di swap).
-processore in grado di bloccare un processo, salvando lo stato del processo in ogni momento, eseguire una trap e riprendere l'esecuzione del processo. Questa operazione pare banale, ma non è così semplice. Infatti si hanno casi diversi a seconda di dove si verifica il page fault. Ad esempio se esso si verifica nella fase di prelievo di un'istruzione, basta rieseguire quello stesso prelievo quando la pagina sarà caricata; se invece il page fault si verifica durante il caricamento di un operando, si dovrà ripetere anche la decodifica dell'istruzione. Il caso peggiore si ha quando un'istruzione deve modificare una serie di locazioni diverse, in cui si può verificare che la sequenza di origine e di destinazione si sovrappongano. In questo caso esistono diverse tecniche per aggirare il problema, come una analisi preventiva della situazione (prima di eseguire l'operazione vera e propria), oppure l'uso di registri temporanei.
Prestazioni della paginazione su richiesta
Il tempo di accesso effettivo se si utilizza la paginazione su richiesta è, in caso assenze di page fault, uguale al tempo di accesso alla memoria. Nel caso in cui si assuma che ci sia una probabilità p che si verifichi un page fault, il tempo di accesso complessivo è dato dalla somma pesata del tempo di accesso alla memoria principale e dell'accesso alla memoria secondaria + il tempo di gestione della trap. Siccome gli ordini di grandezza tra memoria principale e secondaria sono circa 6, è necessario che la probabilità che si verifichi un page fault sia molto piccola.
Grazie alla paginazione su richiesta si può anche utilizzare il meccanismo della copiatura su scrittura. Molte chiamate di sistema per la creazione dei processi, come la fork(), utilizzano questa strategia. Nel momento in cui viene creato un processo con il metodo fork(), non si copia lo spazio di indirizzamento dei due processi, ma lo si sdoppia solo nel caso di scritture nello spazio condiviso.
Nel caso di paginazione su richiesta è possibile che non sia conveniente causare molti page fault nella fase di caricamento del processo. Per questo motivo è utile caricare preventivamente un certo numero di pagine all'avvio di processi di modeste dimensioni.
Gestione dei page fault
Se si utilizza la paginazione su richiesta nel momento che si verifica un page fault non è detto che esista un frame disponibile per il caricamento della pagina richiesta. In questo caso si parla di sovrallocazione della memoria. Il sistema operativo può scegliere tra diverse alternative:
-terminare il processo utente (non viene garantita la corretta esecuzione di un processo).
-scaricare dalla memoria il processo e attendere che la memoria si liberi (viene diminuito il grado di multiprogrammazione).
-sostituire una pagina non utilizzata con quella richiesta.
Questa ultima tecnica è la più interessante, in quanto permette l'implementazione ottimale della paginazione su richiesta. Si nota, però, che ogni volta che si verifica un page fault è necessario accedere due volte alla memoria secondaria, una volta per aggiornare il contenuto presente in memoria primaria, e la seconda per prelevare la nuova pagina dalla memoria secondaria. La trap risulta essere abbastanza onerosa, ed è per questo che spesso per evitare sovrascritture inutili si utilizza un bit di modifica, che permette di verificare se la pagina sia stata modificata dopo il caricamento in memoria primaria.
Per diminuire il numero dei page fault è importante che tutti i processi abbiano un numero minimo di frame a disposizione. Questo valore è dato dall'architettura e non può essere modificato dal programmatore.
In più, per gestire la sostituzione di pagina in modo rapido sono necessari due tipologie di algoritmi:
-algoritmi per l'allocazione dei frame, che permettono di stabilire quanti frame sono da attribuire a ciascun processo.
-algoritmi per la sostituzione delle pagine, che selezionano il frame da spostare in memoria secondaria in caso di page fault.
| < Prec. | Succ. > |
|---|
