Esercitazione Sistemi Operativi a.a. 1999/2000

Gestione della memoria

Modificare il gestore della memoria di MINIX in modo che sia eliminata la frammentazione esterna, mediante compattazione; in particolare si richiede

• di realizzare uno schema per la gestione della memoria che integri le funzioni fornite;
• di estendere la libreria con la nuova system call compact che permette di effettuare esplicitamente la compattazione della memoria, richiamando l'algoritmo realizzato;
• di realizzare un "esempio di test", cioe' un insieme di processi che includa una richiesta di allocazione di memoria che viene soddisfatta solo dopo aver invocato la compact, ma non e' soddisfatta da Minix originale.
• Sintassi di compact:

Consegnare il seguente materiale:

• documentazione cartacea;
• un dischetto di bootstrap del sistema Minix modificato contenente inoltre, in due directories distinte, il sorgente dei file modificati (directory newsrc), sorgenti ed eseguibili dei programmi di test (directory test), makefiles e scripts necessari alla ricompilazione di Minix modificato ed alla ricompilazione ed esecuzione dei tests.

Data ultima di scadenza: giovedi' 20 gennaio 2000.

NOTE:

• E' possibile consegnare prima di tale data!
• Si suggerisce ai gruppi che in tale data non avessero completato l'esercitazione di consegnare comunque quanto fatto, spiegando chiaramente cosa manca o cosa non funziona correttamente: potra` cosi`essere valutato il lavoro svolto, al fine di una eventuale ammissione all'orale (con voto di laboratorio piu' basso)

Inserire il materiale in una busta chiusa con sopra scritti numero del gruppo e nome-cognome-login di ogni componente e consegnarla IN BUCA a Dodero o Gianuzzi. Tutto il materiale consegnato (documentazione e dischetti) dovra' essere identificato allo stesso modo (onde evitare disastri se qualcosa cadesse per terra, si rimescolasse il contenuto delle buste ecc).

Per valutare l'esercitazione si terra' conto di tutto il materiale consegnato, in particolare:

• dell'esecuzione del sistema modificato, passando i tests forniti piu' eventualmente altri;
• del codice sorgente modificato (chiarezza delle modifiche, semplicita' della modifica implementata ecc.)
• della documentazione consegnata (coerenza, completezza, chiarezza ecc.)

Documentazione

1. Files sorgenti

Fornire un listato di tutti i files modificati; per files in cui le modifiche si riducano a una o pochissime righe puo' essere listata solo la parte "intorno" a tale modifica.

Le modifiche apportate ai sorgenti Minix devono essere comunque identificate da commenti "speciali" e se necessario ulteriormente commentate seguendo lo "stile" di Minix stesso.

Esempio di commenti "speciali": /* modifica gruppo xx */ ... /* fine modifica gruppo xx */

2. Documentazione cartacea

La documentazione cartacea puo' essere consegnata manoscritta (purche' chiara e leggibile) oppure scritta con word processors, oppure meta' e meta', ecc. Essa deve essere sintetica, in particolare non devono essere riportate informazioni contenute in questo foglio, sul Tanenbaum ecc.

La documentazione deve contenere una copertina che riporti nome, cognome, login, data e FIRMA dei componenti il gruppo che hanno effettivamente svolto l'esercitazione.

Nel testo della documentazione devono essere presenti in modo chiaro le seguenti informazioni:

informazioni di utente: deve essere possibile a chiunque sia in possesso dei dischetti e della documentazione, ricreare Minix modificato, ripassare i tests ecc.

informazioni di sistema: chi fosse interessato a leggere i sorgenti C modificati, deve trovare informazioni su come e' stata fatta la modifica. Vanno elencati: i files contenuti nei dischetti, e per ciascun file le modifiche, sia inserimenti sia cancellazioni, apportate alle strutture dati e alle funzioni ivi contenute. Delle modifiche va data motivazione e descrizione sintetica. La descrizione va data in italiano o in pseudo-codice (bastano poche righe). Non va descritta l'operazione riga per riga!

(esempio di cosa NON scrivere: la funzione pinco() confronta il primo parametro con zero e se essi sono uguali, azzera anche il secondo parametro. Chiunque leggera' la documentazione sa anche leggere un IF!)

informazioni sui tests: va motivata la scelta dei programmi di tests, e ne vanno riportate le modalita' di esecuzione. In particolare predisporre scripts che ricompilano, lanciano programmi in background ecc. Dei singoli programmi che compongono il test riportare solo le caratteristiche rilevanti (il sorgente dovrebbe essere comprensibile con l'aiuto al piu' di qualche commento).

(esempio: il programma P1 ha due loop annidati il cui scopo e' di ritardare il processo per almeno..., nel test si lanciano quattro copie di P1 e due di P2, e si osserva che ....)

Consigli utili (a chi non ha mai realizzato grossi programmi):

L’esercitazione si compone di tre parti:

1. l’inserimento del nuovo algoritmo all’interno di MM: occorre innanzi tutto comprendere bene MINIX originale e quindi le porzioni di codice gia' fornite che realizzano una parte del nuovo algoritmo; dopo si puo' procedere a scrivere il codice mancante;
2. l’inserimento di una system call (si vedano in proposito alcune note utili)
3. la realizzazione di un esempio in cui Minix originale fallisce e Minix modificato non fallisce (chiamando la compact).

Si raccomanda di progettare e realizzare separatamente le tre parti (non fare tutte le modifiche contemporaneamente!)

Si raccomanda quindi di sviluppare versioni bootabili di Minix intermedie: ad es. una in cui e’ definita la system call compact (ma non fa nulla), una in cui e’ realizzato il nuovo algoritmo ecc.

Suggerimenti dettati dall’esperienza (e validi anche dopo la consegna):

1. Tenere sempre copie di tutto cio’ che e’ funzionante anche se incompleto (la catastrofe e’ in agguato) e copie di modifiche parziali ecc. almeno come sorgenti.
2. Ripulire periodicamente le varie directories di tutte le prove non funzionanti ecc. (attenzione: potreste cancellare le versioni buone e lasciare quelle non funzionanti! Ma se non lo fate dopo un po’ perdete il filo)
3. Fare degli script per tutte le sequenze di comandi non banali e ripetute sovente, per uso vostro oltre che per consentire ai docenti di ricreare eventuali dischetti di boot, ricompilare esempi ecc.
4. Scrivere la documentazione man mano che si fanno le modifiche (non le ultime due ore prima della consegna!) e tenerla coerente con le stesse.

Procedure fornite o da completare:

/*=============== move_block ===================*/
/* sposta un blocco di processi contigui e ne cambia i relativi slot nella tabella dei processi di MM e FS
- La mem_copy sposta materialemnte il blocco
- Il ciclo for cambia gli slot dei processi che hanno indirizzo iniziale compreso tra dove bisogna cominciare a copiare il blocco e dove termina il blocco stesso (infatti non vi sono piu` processi attivi in tale area)
- La sys_newmap trasmette i cambiamenti alla tabella del kernel
- Ritorna l'indirizzo successivo alla fine del blocco spostato
*/

/*=============== clicks_to_K ===================*/
/* converte il parametro da clicks a Kbytes (risultato)
*/

/*=============== write_proc ===================*/
/* stampa informazioni sul processo corrente
*/

/*=============== write_hole ==================*/
/* stampa informazioni sulla tabella degli holes
*/

/*=============== aux_do_comp ===================*/
/* compatta la memoria per ottenere il numero di clicks passati come parametro
- scorre la lista dei buchi finche` la somma delle loro lunghezze e` maggiore o uguale al numero di clicks richiesti e salva l'indirizzo dell'ultimo buco necessario
- a partire dal primo buco compatta attraverso chiamate alla move_block tutti i blocchi compresi tra due buchi successivi della corrispondente lista fino ad arrivare all'ultimo buco necessario
- cancella dalla lista dei buchi quelli cosi' utilizzati
- libera la memoria inutilizzata
- ritorna l'indirizzo iniziale della memoria richiesta
*/

/*=============== do_compact ===================*/
/* implementa la system call compact
*/

/*=============== max_hole ===================*/
/* Questa funzione si sostituisce a quella di Minix originale e calcola la somma dei
buchi liberi, anziche' la dimensione del max buco libero
*/