Componenti di un
sistema operativo
Processori: cervello del computer
RAM: volatile
Moduli I/O: comprende i dischi, i dispositivi di comunicazione e altri dispositivi come mouse e tastiera
Bus di sistema: mezzo per permettere la comunicazione tra le parti interne del computer
Registri I registri sono delle sequenze di celle di memoria, in cui si possono leggere e scrivere dati, in particolare risultati di operazioni.
Sono molto più veloci rispetto alla memoria primaria.
- Registri visibili all'utente: usati da chi programma in assembler o da compilatori di linguaggi non interpretati
- Registri interni: gestiti dal firmware e permettono la comunicazione tra memoria e I/O
- Registri di controllo e di stato: usati dal processore per controllare l'uso dello stesso
Esecuzione di
un'istruzione Ci sono due fasi: fetch della memoria principale ed esecuzione delle istruzioni.
Il PC mantiene l'indirizzo della prossima istruzione mentre l'IR contiene l'istruzione prelevata.
Esistono vari tipi di istruzioni, ma in generale fuzionano tutte allo stesso modo
Interruzioni Le interruzioni bloccano l'esecuzione sequenziale del programma in modo inaspettato e attivano l'esecuzione del
software di sistema, che p parte del sistema operativo
Possono avvenire per varie ragioni e si dividono in due classi principali:
- Interruzioni sincrone, ossia causarte da errori interni al programma, che vengono sollevate immediatamente:
- I faults sono errori corregibili
- Gli aborts non sono corregibili
- Nelle traps/syscall si riparte dall'istruzione successiva
- Interruzioni asincrone, generalmente causate da un evento esterno. In generale, dopo l'handler si riparte
dall'istruzione successiva, a meno che la computazione non sia stata abortita. Si dividono anche queste in
sottocategorie:
- Le interruzioni da I/O, generate dal controllore di un dispositivo input/output
- Le interruzioni da fallimento hardware, causate da un'improvvisa mancanza di potenza
- Le interruzioni da timer, generate da un timer all'interno del processore e servono al sistema operativo
per eseguire alcune operazioni a intervalli regolari
Interrupt handler Funzione in cui sistema operativo e hardware collaborano per salvare le informazioni importanti, come registro
di stato e program counter
La chiamata di funzione non è scritta dal programmatore ma avviene in moido inaspettato, per questo
bisogna salvare queste informazioni
Le interruzioni possono essere sequenziali o annidate, inoltre gli interrupt possono essere disabilitati, quindi le
interruzioni si generano e non sono gestite
Metodi per la
gestione I/O I/O programmato: tutto è gestito dalla CPU
I/O da interruzione: la CPU manda l'istruzione e si mette a fare altro. Quando l'I/O è pronto a scambiare dati, il
processore viene interrotto
Nei computer moderni si accede direttamente alla memoria: quando l'operazione è completata, la CPU non si deve
più preoccupare di trasferire i dati perche i dispositivi I/O vanno in memoria
Multiprogrammazione: Capacità di un processore di eseguire più programmi contemporaneamente
Gerarchia della memoria: La memoria è composta da vari livelli: man mano che si scende, diminuiscono velocità di accesso, costo
al bit e frequenza di accesso, emntre aumenta la capacità
Cache La cache contiene copie di porzioni di memoria principale e viene gestita dall'hardware. Il processore controlla se il dato è
nella cache: se non c?è, il corrispondente blocco di memoria viene caricato. Tutto questo viene fatto perché probabilmente
questo dato potrà servire ancora nell?immediato futuro, e così è meno costoso accedervi
Naturalmente, più grande è il blocco di memoria maggiori sono gli accessi riusciti, ma è bene non aumentare troppo le
dimensioni, poiché a quel punto verranno rimossi più dati.
- Funzione di mappatura ? determina la locazione della cache dove va messo il blocco.
- Algoritmo di rimpiazzamento ? sceglie quale blocco va rimpiazzato. Ne esistono di diversi, per esempio LRU rimuove
il blocco più vecchio.
- Politica di scrittura ? determina quando si scrive in memoria. Ad esempio ogni volta che un blocco viene modificato
(write through) o quando il blocco è rimpiazzato (write back). In teoria cerchiamo di minimizzare la scrittura, quindi è
probabile trovare la memoria in uno stato obsoleto.
Sistema Operativo Il sistema operativo offre una serie di servizi come esecuzioni di programmi, accesso ai dispositivi I\O, accesso al
sistema operativo stesso, sviluppo di programmi, rilevamento di e reazione ad errori, accounting
Il sistema operativo è un programma che controlla l?esecuzione di programmi applicativi: è un?interfaccia tra le
applicazioni e l?hardware, e i suoi obiettivi sono convenienza, efficienza e capacità di evolvere.
Inoltre, il sistema operativo gestisce le risorse (come un software, ma con privilegi più alti) e concede il controllo
del processore ad altri programmi.
Il kernel è la parte del sistema operativo che si trova sempre in memoria principale: contiene le funzioni più usate.
Elementi del
sistema operativo
Viene visto come una serie di livelli: ogni livello si occupa di un sottoinsieme delle funzioni del sistema e si basa sul
livello immediatamente inferiore. In questo modo i problemi vengono decomposti in problemi più semplici.
- Livello 1 ? circuiti elettrici, qui si resettano registri e si leggono locazioni di memoria.
- Livello 2 ? insieme di istruzioni macchina, per esempio add, subtract?
- Livello 3 ? concetto di subroutine (procedura) con operazioni di chiamata e ritorno.
- Livello 4 ? interruzioni.
- Livello 5 ? processo come programma in esecuzione, sospensione e ripresa.
- Livello 6 ? dispositivi di memorizzazione secondaria, trasferimento di blocchi dati.
- Livello 7 ? spazio logico degli indirizzi, organizza spazio degli indirizzi virtuali in blocchi.
- Livello 8 ? comunicazioni tra processi.
- Livello 9 ? salvataggio di file con nome.
- Livello 10 ? accesso a dispositivi esterni con interfacce standard.
- Livello 11 ? associazione tra identificatori interni ed esterni.
- Livello 12 ? supporto di alto livello,
- Livello 13 ? interfaccia utente.
Architettura UNIX
Il kernel Linux è un mix tra kernel monolitico (kernel tutto in memoria da boot a spegnimento) e microkernel (minima
parte del kernel in memoria, il resto caricato all?occorrenza): il monolitico infatti è più veloce, ma occupa più spazio,
nonostante ciò è usato dalla maggior parte dei sistemi operativi moderni. Linux possiede i moduli, ovvero alcune
parti possono essere tolte o aggiunte a richiesta dall?immagine in memoria del kernel.
Processi Il sistema operativo si occupa principalmente di gestire i processi, ovvero le computazioni che si vuole eseguire
Il sistema operativo permette l?esecuzione alternata di processi multipli, assegna le risorse ai processi e le protegge da altri
processi; inoltre permette ai processi di scambiarsi informazioni e la sincronizzazione.
Un processo è un?istanza di un programma in esecuzione su un computer, che viene assegnata a un processore per la sua
esecuzione
È composto da una serie di istruzioni, da uno stato e da un insieme di risorse, ovvero da codice (istruzioni da
eseguire), insieme di dati e attributi che ne descrivono lo stato
Short Term
Scheduling
Quello eseguito più frequentemente, viene invocato sulla base di eventi: il suo scopo è allocare
tempo di esecuzione su un processore per ottimizzare il comportamento del sistema, in base a
indici prestazionali.
i criteri utente prestazionali sono:
- turnaround time (tempo di ritorno) ? per i batch;
- response time ? tempo tra sottomissione richiesta e inizio della risposta all?interazione, si
usa nei processi interattivi. Qui lo scheduler deve minimizzare il tempo di risposta medio e
massimizzare gli utenti con un buon tempo di risposta;
- deadline ? quando si possono specificare, lo scheduler deve massimizzare il numero di
scadenze rispettate, quindi poca variabilità nei tempi di risposta e ritorno.
L?unico criterio utente non prestazionale è la predictability: legato alla deadline, si vuole che
lanciando lo stesso processo più volte ci metta più o meno lo stesso tempo
Invece per quanto riguarda i criteri di sistema prestazionali abbiamo:
- throughput (volume di lavoro) ? dobbiamo massimizzare il numero di processi completati
per unità di tempo: infatti il throughput è una misura di quanto lavoro viene effettuato e
dipende anche da quanto tempo richiede un processo in media.
- processor utilization ? percentuale di tempo in cui il processore viene usato, dev?essere il
più grande possibile. Utile per sistemi costosi e condivisi tra più utenti.
I criteri di sistema non prestazionali sono:
- fairness ed enforcing priorities ? tutti i processi devono essere trattati allo stesso modo
senza favoritismi. Se ci sono priorità, però, lo scheduler favorisce quelli a più alta priorità,
quindi bisogna creare una coda per ogni livello di priorità. Attenzione alla starvation: man
mano che l?età del processo aumenta\le volte in cui è andato in esecuzione sono poche la
priorità cresce.
- balancing resources ? le risorse del sistema devono essere usate il più possibile, quindi
processi che usano meno le risorse più usate sono favoriti.
- turn-around time ? tempo tra creazione di un processo e suo completamento, comprende
tempi di attesa: in un processo batch è minimo.
Funzione di
selezione Sceglie il processo da mandare in esecuzione, dipende da w (tempo trascorso in attesa), e (tempo trascorso in
esecuzione) e s (tempo totale richiesto, incluso e). All?inizio s va stimato, visto che e=0.
Abbiamo due modalità di decisione:
- non-preemptive ? se un processo è in esecuzione, attendo la fine o una richiesta bloccante;
- preemptive ? il sistema può interrompere un processo in esecuzione, che in tal caso diventa ready. Il
processo può essere bloccato per l?arrivo di nuovi processi o per un interrupt.
FCFS First Come First Served, tutti i processi sono messi nella coda ready e quando un processo è terminato si passa a quello
che ha aspettato più tempo. Si favoriscono i processi che usano più CPU ed è non-preemptive. Molto equo, ma un
processo corto deve attendere molto.
Round
Robin
Ad intervalli periodici si genera un?interruzione di clock: il processo in esecuzione allora va nella coda dei ready. Se poi
esso arriva ad un?istruzione di I\O prima dell?interruzione, viene spostato nella coda dei blocked e si seleziona il prossimo
processo ready (FIFO).
Quindi c?è preemption basata su un clock, e se il quanto di tempo è maggiore (ma non troppo, o si finisce in FCFS) del
tipico tempo di interazione allora è ottimale: il tipico tempo di interazione è solo stimato.
Vengono favoriti i processi CPU-bound poiché usano tutto il loro quanto di tempo; invece gli I\O bound usano solo una
porzione del loro quanto di tempo fino alla richiesta, il che non è equo ed è inefficiente
La soluzione dunque è round-robin virtuale: dopo un completamento di I\O il processo va in una nuova coda
che ha priorità sui ready, ma solo per la porzione del quanto che gli restava da completare. In questo modo
migliora la fairness.
SRT Shortest Remaining Time, è come SPN, ma preemptive: stima il tempo rimanente richiesto per l?esecuzione e prende
quello più breve, perciò un processo può essere interrotto solo quando ne arriva uno appena creato. Ci può essere
starvation.
HRRN Highest Response Ratio Next, massimizza il rapporto (w+s)/s, con w=tempo trascorso in attesa e s=tempo totale richiesto:
non guardo solo il tempo che ci mette, ma anche quello che ha passato in attesa. No starvation.
Scheduling
in UNIX Combina priorità e round robin: un processo resta in esecuzione al massimo un secondo, ci sono diverse code a seconda
della priorità, e all?interno di ciascuna coda si usa il round robin.
Architetture
multiprocessore
Sono caratterizzati da cluster (quindi ogni processore ha la sua RAM), processori specializzati (per esempio, ogni
dispositivo di I\O ha un suo processore) e multi-core che condividono la RAM (ovvero, un solo SO controlla tutto).
Lo scheduler su architetture multiprocessore può avere assegnamento statico o dinamico.
Nell?assegnamento statico, quando viene creato un processo, gli viene assegnato un processore, e per
tutta la sua durata resterà lì. Questo metodo è semplice da realizzare, c?è poco overhead, ma un
processore può rimanere idle.
Nell?assegnamento dinamico, un processo può essere eseguito su diversi processori. Stabiliamo per
semplificazione che solo i processi utente possono spostarsi, poiché il SO deve restare su un processore
fisso.
Scheduling in
Linux
Lo scheduling in Linux è preemptive a priorità dinamica, come quello di UNIX; la differenza sta nel consentire
maggiore velocità e servire in modo appropriato i processi real-time. Per fare ciò, l?hardware manda un timer
interrupt ogni 1 ms per consentire la revisione delle priorità.
Gestione della
memoria
Il SO si occupa anche di porre dei limiti di memoria a ciascun processo: se ogni processo gestisse la propria
memoria, ogni processo userebbe tutta la memoria a disposizione, e non ci sarebbe multiprogrammazione. Gestire
la memoria include lo swap di blocchi di dati dalla memoria secondaria: questa gestione è più lenta del processore,
perciò sta al SO pianificare lo swap in modo intelligente. Inoltre, bisogna far sì che ci siano sempre un numero
ragionevole di processi pronti all?esecuzione, in modo che il processore sia sempre al lavoro.
Abbiamo cinque requisiti fondamentali per la gestione della memoria: rilocazione, protezione, condivisione,
organizzazione logica e fisica.
Rilocazione Il programmatore non deve sapere dove il programma verrà caricato: i riferimenti alla memoria
devono essere tradotti nell?indirizzo fisico ?vero?, in preprocessing o run-time (in questo caso
occorre supporto hardware).
Quando viene generato codice eseguibile, il linker mette tutto insieme: il risultato è un load
module, perché può essere tradotto dal loader. Vengono escluse dal linker le librerie
dinamiche, mentre quelle statiche passano per esso, e il load module viene caricato dal loader
in memoria principale con le librerie dinamiche.
Entrambi i tipi di librerie sono collezioni di funzioni che implementano funzionalità utili a diversi
programmi: quelle statiche sono messe in una parte di codice di un programma, mentre nelle
dinamiche la stessa copia può essere utilizzata tra più programmi diversi, quindi il loader le
recupera e le carica in un?area di memoria, così ce n?è solo una copia caricata in RAM. Così si
risparmiano risorse e, se ci sono nuove versioni delle librerie, basta aggiornare quella presente
nel SO.
Protezione I processi non devono accedere a locazioni di memoria di un altro processo, a meno che non
siano autorizzati: a causa della rilocazione, si può fare solo a tempo di esecuzione, pertanto
serve l?aiuto dell?hardware.
Condivisione
Deve essere possibile permettere a più processi di accedere alla stessa zona di memoria
dai processi: per esempio quando più processi vengono creati eseguendo più volte lo stesso
codice sorgente, quindi è più utile che lo condividano. Ci sono anche casi in cui processi
diversi vengono esplicitamente programmati per accedere a sezioni di memoria comuni
usando chiamate di sistema (thread di uno stesso processo).
Organizzazione
Logica
A livello hardware, la memoria è organizzata in modo lineare; a livello software, i programmi
sono scritti in moduli, che possono essere compilati separatamente. A ciascun modulo
possono essere dati diversi permessi, e possono essere condivisi tra processi. Il SO deve
offrire tali caratteristiche, facendo da ponte tra la prima visuale e la seconda.
Organizzazione
fisica
Sarebbe la gestione del flusso tra RAM e memoria secondaria: non può essere lasciata al
programmatore, poiché la memoria potrebbe non essere sufficiente a contenere il
programma ed i suoi dati. La tecnica dell?overlaying permette a più moduli di essere
posizionati nella stessa zona di memoria in tempi diversi, ma è difficile da programmare,
poiché il programmatore non sa quanta memoria avrà a disposizione, quindi ci deve pensare
il SO.
Partizionamento
Uno dei primi metodi per la gestione della memoria prima che venisse introdotta quella virtuale: è utile per capire
quest?ultima. Abbiamo diverse tecniche di partizionamento: fisso, dinamico, paginazione semplice e con memoria
virtuale, segmentazione semplice e con memoria virtuale.
Gestione dell'I/O
Definiamo tre categorie di dispositivi:
- Leggibili dall?utente ? stampanti, mouse, usati per la comunicazione diretta con l?utente.
- Leggibili dalla macchina ? chiavi USB, usati per la comunicazione con materiale elettronico.
- Di comunicazione ? modem, Wi-Fi, per comunicare con dispositivi remoti.
Un dispositivo di input prevede di essere interrogato sul valore di una certa grandezza fisica al suo interno
(esempio: la tastiera identifica il codice Unicode).
Un processo che effettua una syscall read su un dispositivo del genere vuole conoscere questo
dato per poterlo elaborare (esempio: un editor di testo rappresenta il codice con il simbolo
corrispondente).
Un dispositivo di output prevede di poter cambiare il valore di una certa grandezza fisica al suo interno
(esempio: nel monitor il valore RGB dei pixel).
Un processo che effettua una syscall write su un dispositivo del genere vuole cambiare qualcosa:
spesso l?effetto è visibile dall?utente.
I dispositivi differiscono in:
- Data rate ? frequenza di accettazione\emissione di dati, velocità di trasferimento.
- Applicazione ? i dischi sono usati per memorizzare file, quindi hanno bisogno di un software per la loro
gestione. Un terminale usato da un amministratore ha priorità più alta.
- Complessità nel controllo ? molte cose vengono controllate da hardware dedicato. Mouse e tastiera sono
molto semplici, il più difficile è il disco. Molte cose sono controllate da hardware dedicato poiché col software
sarebbe molto difficile.
- Unità di trasferimento dati ? può essere blocco di byte di lunghezza fissa (chiavi USB, DVD etc), stream di
byte\caratteri, cose che non siano memoria secondaria (stampanti, terminali).
- Rappresentazione dei dati ? i dati possono essere rappresentati con codifiche diverse.
- Condizioni di errore ? la natura degli errori varia, ad esempio per come vengono notificati, gestiti, e per le
loro conseguenze.
Effettuare l'I/O
Ci sono 3 metodi:
- programmato
- guidato dagli interrupt
- accesso diretto in memoria
Il processore delega le operazioni di I\O al modulo DMA, direct memory access, che trasferisce i dati direttamente
da\verso la memoria principale; quando finisce il modulo genera un interrupt per il processore.
Il secondo obiettivo è la generalità: cerchiamo di gestire i dispositivi in modo uniforme, nascondendo i loro dettagli
nelle procedure di basso livello e progettare le funzioni in modo modulare e gerarchico. Ad esempio, le funzionalità
base sono read, write, unlock, etc.
Gerarchia di un
dispositivo di I/O
- Dispositivi locali ? in cima i processi utente, poi i logical I\O dove il sistema viene visto come una risorsa logica
(open, close, read). Poi device I\O, dove le richieste logiche diventano una sequenza di comandi di I\O. Poi
scheduling and control, che sceglie l?ordine di esecuzione dei processi. Infine l?hardware traduce le richieste in
input.
- Dispositivi di comunicazione ? simile, ma c?è l'architettura di comunicazione al posto del logical, poiché ci
possono essere diverse architetture di comunicazione.
- File system ? si accede a dischi meccanici. Usiamo moduli diversi perché i problemi sono legati alla gerarchia
del tipo di sistema: sotto la directory management, che racchiude le operazioni utente che hanno a che fare con i
file (crea, cancella, sposta), abbiamo il file system, che dà struttura logica alle operazioni. Sotto ancora,
l?organizzazione fisica, ossia da identificatori a indirizzi. Sotto ci sono device I\O, scheduling and control e
hardware.
Sistemi di
buffering
Senza buffer, il SO accede al dispositivo nel momento in cui ne ha necessità.
- Con un buffer singolo, esso viene creato in memoria principale per una data richiesta di I\O; lettura e scrittura
sono separate e sequenziali. I buffer singoli si dividono a loro volta in orientati ai blocchi e agli stream: in quello
orientato ai blocchi i trasferimenti sono fatti al buffer in system memory, quindi il blocco viene mandato nello
spazio utente quando necessario, ma il prossimo blocco viene comunque letto nel buffer. Vi è quindi un input o
lettura anticipata, e un output posticipato. I dati solitamente sono acceduti sequenzialmente, quindi c?è buona
possibilità che servirà e sarà già stato letto.
In quello orientato agli stream i terminali tipicamente hanno a che fare con linee, quindi si bufferizza una linea
intera di input\output, o un byte alla volta per i device in cui un singolo carattere premuto va gestito.
- Con un buffer doppio, un processo può trasferire dati da\a uno dei buffer, mentre il SO svuota\riempie l?altro.
Lettura e scrittura sono parallele.
- Nel buffer circolare, ho più di due buffer e ciascuno è un?unità. Viene usato quando l?operazione di I\O deve
tenere il passo del processo.
Pro e contro
dei buffer
Il buffering smussa i picchi di richieste di I\O, ma se la domanda è molta i buffer si riempiono e si perde il vantaggio.
Serve quando ci sono molti e vari dispositivi, perché migliora l?efficienza dei processi e del SO. Inoltre il buffer
introduce overhead a causa della copia intermedia in kernel memory
Come
funzionano i
dischi Gli HDD hanno all?interno una serie di dischi suddivisi in track e settori
Ciascuna track è divisa in settori, separati da un intersector gap
Sul disco i dati vengono scritti per settori, quindi l?unità di accesso atomico su un disco è il settore (di solito 512
byte). La lettura dei dischi è gestita dal controller dei dischi stessi, così da togliere lavoro al SO
I dati si trovano sulle tracce (corone concentriche) su un certo insieme di settori, quindi per leggere\scrivere occorre
sapere su quale traccia si trovano i dati, e in quale settore.
Per selezionare una traccia bisogna spostare una testina se mobili, o selezionare una testina, se fisse; per
selezionare un settore bisogna aspettare che il disco ruoti. Un?operazione su disco dipende da molti dettagli
Il tempo di accesso è la somma di tempo di posizionamento (seek) della testina sulla traccia e ritardo di rotazione
(rotational delay), ovvero il tempo che l?inizio del settore impiega a raggiungere la testina. Invece il tempo di
trasferimento è il tempo necessario a trasferire i dati che scorrono sotto la testina. A parte si considerano wait for
device (attesa che il dispositivo venga assegnato alla richiesta) e wait for channel (se più dischi condividono lo
stesso canale, attesa che il sottodispositivo sia assegnato alla richiesta).
Politiche di
scheduling
del disco
Consideriamo solo il seek time e il confronto viene fatto con la politica random (la peggiore).
- FIFO ? le richieste sono servite sequenzialmente. Se ci sono molti processi, come il random.
- Priorità ? l?obiettivo non è ottimizzare il disco. Non va bene per i DBMS, i processi batch corti hanno priorità
più alta, quelli più lunghi potrebbero dover aspettare troppo.
- LIFO ? si riferisce all?utente, non alla transazione. Ottimo per DBMS con transazioni, possibile la starvation
se lo stesso utente fa le richieste: probabilmente vuol dire che sta accedendo sequenzialmente a un file.
- Minimo tempo di servizio ? la richiesta che minimizza il movimento del braccio, quindi sceglie il tempo di
posizionamento minore relativo. Possibile la starvation.
- SCAN ? si scelgono le richieste in modo che il braccio si muova sempre in un verso e poi torni indietro. No
starvation ma poco fair.
- C-SCAN ? il braccio quando torna indietro non sceglie richieste, quindi i bordi non sono visitati due volte in
poco tempo.
- FSCAN ? quando SCAN inizia tutte le richieste sono nella coda F; le richieste che arrivano mentre SCAN
scorre vengono aggiunte a R. Quando SCAN finisce si scambiano le code.
- N-step-SCAN ? generalizza FSCAN a N>2 code: si accodano le richieste nella coda i-esima finché non si
riempie, poi si passa a quella (i+1) mod N. Se N è alto, le prestazioni sono quelle di SCAN con fairness; se
N=1 si usa il FIFO.
Cache del
disco Si tratta di un buffer in memoria principale, usato per i settori del disco
Contiene la copia di alcuni settori: quando si fa una richiesta di I\O per dati che si trovano su un certo settore, si
vede prima se tale settore è nella cache, se non c?è il settore letto viene anche copiato
Ci sono vari metodi per gestire la page cache, che è hardware e quindi trasparente per il SO.
- LRU ? prendo i settori nella cache da più tempo senza referenze. La cache viene puntata da uno stack di
puntatori: quello riferito più di frequente sta in cima allo stack, quindi ogni volta che viene referenziato torna
in cima allo stack.
- LFU ? prendo il settore con meno referenze: serve un contatore per ogni settore. Se un settore viene
acceduto più volte di fila e poi mai più, andrebbe rimosso, ma qui non succede.
- Frequenza ? stack di puntatori, quando un blocco viene referenziato si sposta in cima e viene spezzato in
due. Poi c'è anche qui un contatore, ma si incrementa solo se è nella parte vecchia, e si sceglie il blocco con
il contatore minimo che è nella parte vecchia; in caso di parità, quello più recente. Quando un blocco vecchio
viene riferito e diventa nuovo, spinge l?ultimo dei nuovi a diventare vecchio. Per evitare che un blocco sia
rimosso solo perché è appena arrivato nella parte vecchia, creiamo una sostituzione a tre segmenti: nuovo
(qui non si incrementano contatori né si rimpiazza), medio (contatori incrementati, ma non rimpiazzati) e
vecchio (contatori incrementati e rimpiazzati).
Requisiti per la
mutua esclusione
- Solo un processo alla volta può essere nella sezione critica per una risorsa.
- Niente deadlock né starvation.
- Nessuna assunzione su scheduling dei processi, né sul loro numero.
- Un processo deve entrare subito nella sezione critica se nessun altro processo usa la risorsa.
- Un processo che si trova nella sezione non critica non può essere bloccato.
- Un processo che si trova nella sezione critica prima o poi deve uscire.
I sistemi con un solo processore permettono solo l?interleaving: un processo viene eseguito finché non
invoca il SO o viene interrotto.
Disabilitare le interruzioni garantisce la mutua esclusione: se il processo può decidere di non essere
interrotto, allora nessun altro lo può interrompere mentre si trova nella sezione critica
Istruzioni macchina
speciali
- Compare and swap: compara due parametri e, se sono uguali, assegna il nuovo valore alla variabile e ritorna il
vecchio valore, altrimenti ritorna il vecchio valore.
- Exchange: scambia due valori in maniera atomica
Semaforo
Valore intero usato dai processi per scambiarsi segnali, ha solo tre operazioni atomiche definite: initialize,
decrement (o semWait, può mettere il processo in blocked così non spreca CPU) e increment (o semSignal, mette
un processo blocked in ready). Sono eseguite in kernel mode e agiscono direttamente sui processi.
La struttura del semaforo contiene un contatore e una coda, usata per mettere i processi in blocked; la wait prende
in input un semaforo, che diminuisce il count e poi verifica se è minore di zero, e in caso positivo mette il processo
nella coda del semaforo e lo blocca; il signal prende in input un semaforo e incrementa il count, se è minore o
uguale a zero rimuove un processo P dalla coda e lo mette a ready.
Al posto del count possiamo mettere una enumerazione con valori 0 e 1: se il valore del semaforo è 1 continuiamo
a eseguire mettendolo a 0, altrimenti si mette un processo nella coda e si blocca. Nel signal invece si controlla la
coda: se è vuota il valore del semaforo va a 1, altrimenti si rimuove un processo dalla coda e si mette nella lista dei
processi ready.
Problema del
produttore /
consumatore
La premessa è che uno o più produttori creano dati e li mettono in un buffer: un consumatore prende dati dal buffer
uno alla volta, e al buffer può accedere un solo processo alla volta. Il problema è assicurare che i produttori non
inseriscano i dati quando il buffer è pieno e assicurare che il consumatore non prenda dati quando il buffer è vuoto,
oltre alla mutua esclusione sull?intero buffer.
Problema di
trastevere
I blocchetti sono macchine, il tubo è una strada che si restringe a senso unico alternato: possono passare massimo
4 auto alla volta. Vince chi arriva prima: assumendo semafori strong, le macchine dovrebbero impegnare la strettoia
nell?ordine con cui vi arrivano (o si accodano dalla propria parte).
Problema del
negozio del
barbiere
La dimensione massima del negozio è max cust; prima ci si siede sul divano, poi da lì si accede a una delle sedie,
si compete per entrambe le risorse. Un certo numero va sul divano, le sedie effettive poi sono di meno; tra tutti
quelli nel negozio si compete per il divano, mentre tra tutti quelli sul divano si compete per le sedie. Il barbiere
dorme o taglia capelli o prende soldi dopo il taglio.
Algoritmo
di Dekker
Riferito alla soluzione del negozio del barbiere: vogliamo implementare il quarto modo
senza livelock: verifichiamo con turn che sia il mio turno, e finché non lo è metto il flag
a false e c?è un busy waiting. Quando sarà il mio turno, rimetto il flag a true, vado in
sezione critica e faccio il flip del turno.
Algoritmo
di Peterson
Simile a Dekker ma dalla struttura diversa: ciclo while infinito e quando entriamo il flag
dice se vogliamo accedere. Poi cambio turno e verifico che, se l?altro processo vuole
entrare ed è il suo turno, non faccio niente; altrimenti vado avanti e alla fine metto il
flag a 0. Così non ho momenti in cui due processi vogliono accedere alla sezione
critica
Interazione dei
processi Dobbiamo soddisfare due requisiti: sincronizzazione e comunicazione.
Lo scambio di messaggi è una soluzione al secondo requisito, poiché funziona sia con memoria condivisa
che distribuita e può essere usata anche per la sincronizzazione. La funzionalità è fornita tramite
send(destination, message) e receive(source, message): message è un input per la send ed un output per
la receive.
La comunicazione però richiede anche la sincronizzazione: il mittente deve inviare prima che il
ricevente riceva.
Nelle operazioni bloccanti sia mittente che destinatario sono bloccati finché il messaggio non è
completamente ricevuto: si chiama rendezvous, e la sincronizzazione è molto stretta.
Il send non bloccante (nbsend) è il più naturale; nella ricezione bloccante il mittente non viene
messo in blocked e il destinatario rimane bloccato finché non riceve il messaggio. Nella ricezione
non bloccante (nbreceive), se c?è il messaggio, esso viene ricevuto, altrimenti va avanti; può
settare un bit nel messaggio per dire se la ricezione è avvenuta. In questo caso, tipicamente non
è bloccante nemmeno l?invio. Queste operazioni sono sempre atomiche.
Il mittente deve poter dire a quale processo vuole mandare il messaggio, idem per il destinatario:
si possono usare indirizzamento diretto o indiretto. Nel diretto la primitiva di send include uno
specifico ID per il destinatario o per un gruppo di destinatari; per la receive, non è detto che ci
sia: con receive(sender, msg) ricevi solo se il mittente coincide con sender; altrimenti
receive(null, msg) ricevi da chiunque. Dentro msg c?è anche il mittente, e ogni processo ha una
coda: una volta piena il messaggio si perde oppure viene ritrasmesso.
Nell?indiretto, i messaggi sono inviati ad una casella di posta condivisa: il mittente manda
messaggi alla mailbox, da dove li prende il destinatario. Se la ricezione è bloccante e ci sono più
processi in attesa su una ricezione, un solo processo viene svegliato. Ci sono similitudini con
produttore\consumatore (se la mailbox è piena? ).
Struttura dei
messaggi
Deadlock Il blocco permanente di un insieme di processi, che competono per delle risorse di sistema o comunicano tra loro:
vengono richieste in contemporanea le stesse risorse da parte di due o più processi.
Con il Joint Progress Diagram analizziamo i diversi percorsi che possono fare i processi in base alle risorse che
richiedono: qui abbiamo un processo su x e uno su y, e vediamo le diverse situazioni in cui i processi si trovano in
caso decidano di accedere in diversi momenti temporali alle risorse. In questo esempio il deadlock è inevitabile
Reusable vs
Consumable
resource
Le reusable sono usabili da un solo processo alla volta, ma non si consumano, ad esempio i file
Le consumable vengono prodotrte e consumate, ad esempio le interruzioni
