Esercitazioni 3 e 4

Università degli Studi della Calabria
Corso di Laurea in Ingegneria Informatica
A.A. 2001/2002
Sistemi Operativi
Corsi A e B
Esercitazioni 3 e 4
Sincronizzazione dei Processi (2a parte)
n Problemi classici di sincronizzazione
n Regioni critiche
n Monitor
Sistemi Operativi
P.Trunfio – R.Ortale
1
Problemi classici di sincronizzazione
n Problema del Bounded-Buffer
n Problema dei Lettori e degli Scrittori
n Problema dei Cinque Filosofi
Sistemi Operativi
P.Trunfio – R.Ortale
Problema del Bounded-Buffer
n Dati condivisi:
Semaforo full, empty, mutex;
Inizialmente:
full = 0, empty = n, mutex = 1
Sistemi Operativi
P.Trunfio – R.Ortale
2
Bounded-Buffer: Processo Produttore
while (true) {
…
produce un item in nextp
…
wait(empty);
wait(mutex);
…
aggiunge nextp al buffer
…
signal(mutex);
signal(full);
}
Sistemi Operativi
P.Trunfio – R.Ortale
Bounded-Buffer: Processo Consumatore
while (true) {
wait(full);
wait(mutex);
…
rimuove un item dal buffer e lo inserisce in nextc
…
signal(mutex);
signal(empty);
…
consuma l’item in nextc
…
}
Sistemi Operativi
P.Trunfio – R.Ortale
3
Problema dei Lettori-Scrittori
n Dati condivisi:
Semaforo mutex, wrt;
int readcount;
Inizialmente:
mutex = 1, wrt = 1, readcount = 0
Sistemi Operativi
P.Trunfio – R.Ortale
Lettori-Scrittori: Processo Scrittore
wait(wrt);
…
scrive
…
signal(wrt);
Sistemi Operativi
P.Trunfio – R.Ortale
4
Lettori-Scrittori: Processo Lettore
wait(mutex);
readcount++;
if (readcount == 1)
wait(wrt);
signal(mutex);
…
legge
…
wait(mutex);
readcount--;
if (readcount == 0)
signal(wrt);
signal(mutex);
Sistemi Operativi
P.Trunfio – R.Ortale
Problema dei Cinque Filosofi
n Dati condivisi:
Semaforo chopstick[] = new Semaforo [5];
Inizialmente tutti i semafori valgono 1
Sistemi Operativi
P.Trunfio – R.Ortale
5
Problema dei Cinque Filosofi
n Filosofo i:
while (true) {
wait(chopstick[i]);
wait(chopstick[(i+1) % 5]);
…
mangia
…
signal(chopstick[i]);
signal(chopstick[(i+1) % 5]);
…
pensa
…
}
Sistemi Operativi
P.Trunfio – R.Ortale
Regioni critiche
n Costrutto di sincronizzazione di alto livello.
n Una variabile condivisa v di tipo T, è dichiarata come:
v: shared T
n La variabile v viene acceduta solo dentro uno statement:
region v when B do S
dove B è una espressione booleana.
n Mentre lo statement S è in esecuzione , nessun altro
processo può accedere la variabile v.
Sistemi Operativi
P.Trunfio – R.Ortale
6
Regioni critiche
n Regioni che fanno riferimento alla stessa variabile
condivisa si escludono reciprocamente .
n Quando un processo prova ad eseguire lo statement
della regione critica, l’espressione booleana B viene
valutata. Se B è true, S viene eseguita. Se è false, il
processo viene ritardato fintanto che B diventa true e
nessun altro processo si trova nella regione critica
associata con v.
Sistemi Operativi
P.Trunfio – R.Ortale
Esempio: Bounded-Buffer
n Dati condivisi:
class buffer {
int pool[] = new int[n];
int count, in, out;
}
Sistemi Operativi
P.Trunfio – R.Ortale
7
Bounded-Buffer: Processo Produttore
n Il processo produttore inserisce nextp nel buffer
condiviso:
region buffer when (count < n) do {
pool[in] = nextp;
in = (in+1) % n;
count++;
}
Sistemi Operativi
P.Trunfio – R.Ortale
Bounded-Buffer: Processo Consumatore
n Il processo consumatore rimuove un item dal buffer
condiviso e lo inserisce in nextc:
region buffer when (count > 0) do {
nextc = pool[out];
out = (out+1) % n;
count--;
}
Sistemi Operativi
P.Trunfio – R.Ortale
8
Implementazione di “region x when B do S” (1)
n Associamo alla variabile condivisa x, le seguenti variabili:
Semaforo mutex, firstDelay, secondDelay;
int firstCount, secondCount;
n L’accesso in mutua escusione alla sezione critica è
garantito da mutex.
n Se un processo non può entrare nella sezione critica
perchè il valore dell’espressione booleana B è false, esso
aspetta prima sul semaforo firstDelay; successivamente
viene spostato sul semaforo secondDelay prima che
possa rivalutare B.
Sistemi Operativi
P.Trunfio – R.Ortale
Implementazione di “region x when B do S” (2)
n firstCount e secondCount tengono conto rispettivamente
del numero di processi in attesa sui semafori firstDelay e
secondDelay.
n L’algoritmo assume un ordinamento FIFO
nell’accodamento dei processi nei semafori.
n Per una modalità di accodamento arbitraria è necessaria
una implementazione più complessa.
Sistemi Operativi
P.Trunfio – R.Ortale
9
Monitor
n Costrutti di sicronizzazione di alto livello che consentono la condivisione
sicura di un tipo di dati astratto tra processi concorrenti.
monitor monitor-name
{
dichiarazione di variabili condivise
procedure entry P1 (…) {
...
}
procedure entry P2 (…) {
...
}
procedure entry Pn (…) {
...
}
{
codice di inizializzazione
}
}
Sistemi Operativi
P.Trunfio – R.Ortale
Monitor
n Per consentire ad un processo di attendere all’interno di un monitor,
si deve dichiarare una variabile condition:
condition x, y;
n Una variabile condition può essere manipolata solo attraverso le
operazioni wait e signal.
F L’operazione
x.wait();
sospende il processo che la invoca fino a quando un altro
processo non invoca:
x.signal();
F L’operazione x.signal risveglia esattamente un processo. Se
nessun processo è sospeso l’operazione di signal non ha
effetto.
Sistemi Operativi
P.Trunfio – R.Ortale
10
Rappresentazione concettuale di un Monitor
Sistemi Operativi
P.Trunfio – R.Ortale
Monitor con variabili condition
Sistemi Operativi
P.Trunfio – R.Ortale
11
Cinque Filosofi (1)
class filosofi // una classe monitor
{
final int thinking=0, hungry=1, eating=2;
int state[] = new int[5]; // gli elementi valgono 0, 1 o 2
condition self[] = new condition[5];
void pickup(int i)
// lucidi seguenti
void putdown(int i)
// lucidi seguenti
void test(int i)
// lucidi seguenti
void init() {
for (int i = 0; i < 5; i++)
state[i] = thinking;
}
}
Sistemi Operativi
P.Trunfio – R.Ortale
Cinque Filosofi (2)
void pickup(int i) {
state[i] = hungry;
test(i);
if (state[i] != eating)
self[i].wait();
}
void putdown(int i) {
state[i] = thinking;
// controlla i vicini a destra e a sinistra
test((i+4) % 5);
test((i+1) % 5);
}
Sistemi Operativi
P.Trunfio – R.Ortale
12
Cinque Filosofi (3)
void test(int i) {
if ( (state[(i + 4) % 5] != eating) &&
(state[i] == hungry) &&
(state[(i + 1) % 5] != eating) ) {
state[i] = eating;
self[i].signal();
}
}
Sistemi Operativi
P.Trunfio – R.Ortale
Implementazione dei Monitor (1)
Implementazione dei monitor tramite semafori:
n Variabili:
Semaforo mutex;
Semaforo next;
int nextCount = 0;
// (inizialmente = 1)
// (inizialmente = 0)
n Ciascuna procedura atomica F deve essere sostituita da:
wait(mutex);
…
corpo di F;
…
if (nextCount > 0)
signal(next);
else
signal(mutex);
n La mutua esclusione all’interno di un monitor è così assicurata.
Sistemi Operativi
P.Trunfio – R.Ortale
13
Implementazione dei Monitor (2)
n Per ciascuna variabile condition x, abbiamo:
Semaforo xSem;
int xCount = 0;
// (inizialmente = 0)
n L’operazione x.wait() può essere implementata come:
xCount++;
if (nextCount > 0)
signal(next);
else
signal(mutex);
wait(xSem);
xCount--;
Sistemi Operativi
P.Trunfio – R.Ortale
Implementazione dei Monitor (3)
n L’operazione x.signal() può essere implementata come:
if (xCount > 0) {
nextCount++;
signal(xSem);
wait(next);
nextCount--;
}
Sistemi Operativi
P.Trunfio – R.Ortale
14
Implementazione dei Monitor (4)
n Costrutto wait con priorità: x.wait(c);
F c: espressione intera valutata quando l’operazione wait viene
eseguita.
F Il valore di c (un numero di priorità) memorizzato con il nome
del processo che è sospeso.
F Quando viene eseguito x.signal, il processo che ha il più basso
numero di priorità viene svegliato.
n Verifica due condizioni per stabilire la correttezza del
sistema:
F I processi utente devono sempre effettuare le invocazioni sui
metodi del monitor secondo una sequenza corretta.
F Occorre assicurare che i processi non cooperanti non tentino di
accedere alle variabili condivise direttamente, bypassando la
mutua esclusione fornita dai monitor.
Sistemi Operativi
P.Trunfio – R.Ortale
15