il semaforo - lialia.disi.unibo.it/courses/sistopls0708/materiale/06... · 2008-02-04 · 4...
TRANSCRIPT
1
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
1
Il semaforo
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
2
Il semaforo
• Strumento linguistico di basso livello per risolvere problemi di sincronizzazione.
• Il meccanismo semaforico e` normalmente utilizzato a livello di macchina concorrente per realizzare strumenti di sincronizzazione di “più alto livello”.
• Disponibile in librerie standard per la realizzazione di programmi concorrenti con linguaggi sequenziali (es. C).
Esempio: libreria LinuxThreads (standard Posix)
2
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
3
Un semaforo e` rappresentato da una variabile di tipo semaphore, definita come una variabile intera non negativa, cui è possibile accedere solo tramite le due operazioni P e V .
Dichiarazione di un oggetto di tipo semaphore:semaphore s=i;
dove i (i=0) è il valore iniziale.
Al tipo semaphore sono associati:
Insieme di valori= { X | X∈N}Insieme delle operazioni= {P,V}
Semaforo: tipo di dati semaphoreSi
stem
iOpe
rati
viLS
–A
.A. 2
006-
2007
4
Operazioni sul semaforo• Un oggetto di tipo semaphore è condivisibile da due o più
processi, che operano su di esso attraverso le operazioni P e V.
Semantica delle due operazioni:void P(semaphore s):
region s << when(vals>0) vals--;>>
void V(semaphore s): region s << vals++;>>
dove vals rappresenta il valore del semaforo.
Essendo l’oggetto s condiviso, le due operazioni P e V vengono definite come sezioni critiche da eseguire in mutua esclusione. Le due operazioni devono essere eseguite in forma atomica.
3
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
5
vals ++vals>0
vals --
sino
V(s)P(s)
Operazioni sul semaforo
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
6
Relazione di invarianza:
Siano:• Is: valore intero=0 con cui il semaforo s viene inizializzato;• nvs: numero di volte che l’operazione V(s) è stata eseguita;• nis: numero di volte che l’operazione P(s) è stata iniziata;• nps: numero di volte che l’operazione P(s) è stata
completata;• bloccatis : numero dei processi sospesi sul semaforo
Semaforo
4
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
7
Semaforo: relazioni di Invarianza
bloccatis = nis – nps
vals = Is + nvs – nps
da cui:
nps = Is + nvs relazione di invarianza
Inoltre:
vals > 0 => bloccatis == 0
bloccatis > 0 => vals == 0
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
8
Uso dei semafori
• Il semaforo viene utilizzato come strumento di sincronizzazione tra processi concorrenti:– sospensione: P(s), s==0– risveglio: V(s), se vi e` almeno un processo
sospeso• Nel seguito verranno illustrati alcuni esempi notevoli
di uso del meccanismo semaforico:– semafori di mutua esclusione– semafori evento– semafori binari composti– semafori condizione– semafori risorsa– semafori privati
5
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
9
Semafori di mutua esclusioneSemaforo binario. Può assumere solo i valori 0 e 1
class tipo_risorsa {<struttura dati di ogni istanza della classe>;semaphore mutex = 1;public void op1( ) { P(mutex); /*prologo*/
<corpo della funzione op1>;V(mutex); /*epilogo*/
}
...public void opn( ) { P(mutex);
<corpo della funzione opn>;V(mutex);
}}...tipo_risorsa ris;ris.opi();
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
10
• In alcuni casi è consentito a più processi di eseguire contemporaneamente la stessa operazione su una risorsa, ma non operazioni diverse.
• Data la risorsa condivisa ris e indicate con op1, …, opn le n operazioni previste per operare su ris, vogliamo garantire che più processi possano eseguire concorrentemente la stessa operazione opi mentre non devono essere consentite esecuzioni contemporanee di operazioni diverse.
Mutua esclusione tra gruppi di processi
6
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
11
Anche in questo caso lo schema è:
public void opi() {<prologoi>;<corpo della funzione opi>;<epilogoi>;}
• prologoi deve sospendere il processo che ha chiamato l’operazione opi se sulla risorsa sono in esecuzione operazioni diverse da opi; diversamente deve consentire al processo di eseguire opi .
• epilogoi deve liberare la mutua esclusione solo se il processo che lo esegue è l’unico processo in esecuzione sulla risorsa o è l’ultimo di un gruppo di processi che hanno eseguito la stessa opi .
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
12
public void opi( ) {P(mi);conti++;if (conti==1) P(mutex); V(mi); <corpo della funzione opi>;P(mi);conti--;if (conti==0) V(mutex);V(mi);
}
<prologoi>
<epilogoi>
7
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
13
semaphore mutex = 1;semaphore ml = 1int contl = 0;public void lettura(…) {
P(ml);contl++;if (contl==1) P(mutex);V(ml); <lettura del file >;P(ml);contl--;if (contl==0) V(mutex);V(ml);
}
public void scrittura(…) {P(mutex); <scrittura del file >;V(mutex);
}
Esempio: Problema dei lettori/scrittoriSi
stem
iOpe
rati
viLS
–A
.A. 2
006-
2007
14
Semafori evento:scambio di segnali temporali
• semafori binari utilizzati per imporre un vincolo di precedenza tra le operazioni dei processi.
Esempio: opa deve essere eseguita da P1 solo dopo che P2 ha eseguito opb
è Introduciamo un semaforo sem inizializzato a zero:• prima di eseguire opa, P1 esegue P(sem); • dopo aver eseguito opb, P2 esegue V(sem).
a
8
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
15
P2 P2
a) b)
P(sem)
opaopb
P1 P2
opaopb
V(sem)
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
16
Due processi P1 e P2 eseguono ciascuno due operazioni pa e pb il primo e qa e qb il secondo.
• vincolo di rendez-vous : l’esecuzione di pb da parte di P1 e qb da parte di P2 possono iniziare solo dopo che entrambi i processi hanno completato la loro prima operazione.
è Scambio di segnali temporali in modo simmetrico: ogni processo quando arriva all’appuntamento segnala di esserci arrivato e attende l’altro.
è Introduciamo due semafori evento sem1 e sem2
Problema del rendez-vous
9
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
17
P2
P1 P(sem2)papbV(sem1)
P(sem1)qa qbV(sem2)
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
18
Semafori binari composti: scambio di dati
• Due processi P1 e P2 si scambiano dati di tipo T utilizzando una memoria (buffer) condivisa .
Vincoli di sincronizzazione:• Accessi al buffer mutuamente esclusivi.• P2 può prelevare un dato solo dopo che P1 lo ha
inserito.• P1, prima di inserire un dato, deve attendere che P2
abbia estratto il precedente.
10
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
19
Scambio di dati: vincoli di precedenza
P1
P2
ini+1ini
esi+1esi
• Utilizziamo due semafori:• vu, per realizzare l'attesa di P1, in caso di buffer pieno;• pn, per realizzare l'attesa di P2, in caso di buffer vuoto;
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
20
void invio(T dato) { T ricezione( ) {P(vu); T dato;inserisci(dato); P(pn);V(pn); dato=estrai();
V(vu);} return dato;
}
buffer inizialmente vuotovalore iniziale P(vu) = 1valore inizialeV(pn) = 0
11
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
21
• pn e vn garantiscono da soli la mutua esclusione delle operazioni estrai ed inserisci.
• La coppia di semafori si comporta nel suo insieme come se fosse un unico semaforo binario di mutua esclusione.
Semaforo binario composto : un insieme di semafori usato in modo tale che:
• uno solo di essi sia inizializzato a 1 e tutti gli altri a zero.
• ogni processo che usa questi semafori esegue sempre sequenze che iniziano con la P su uno di questi e termina con la V su un altro.
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
22
Semafori condizione
In alcuni casi, l'esecuzione di un'istruzione S1 su una risorsa R e` subordinata al verificarsi di una condizione C:void op1( ): region R << when(C) S1;>>
• op1( ) è una regione critica, dovendo operare su una risorsa condivisa R.
• S1 ha come precondizione la validità della condizione logica C.
è Il processo deve sospendersi se la condizione non èverificata e deve uscire dalla regione per consentire ad altri processi di eseguire altre operazioni su R per rendere vera la condizione C.
12
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
23
C
S
falsetrue
C
S
true
P(sem)
V(sem)
false
(a) (b)
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
24
• Lo schema (a) presuppone una forma di attesa attiva da parte del processo che non trova soddisfatta la condizione.
• Nello schema (b) si realizza la region sospendendo il processo sul semaforo sem da associare alla condizione.(semaforo condizione)
• E’ evidentemente necessaria un’altra operazione op2 che chiamata da un altro processo, modifichi lo stato interno di R in modo che C diventi vera.
• Nell’ambito di op2 viene eseguita la V(sem) per risvegliare il processo.
13
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
25
Struttura dati della risorsa Rsemaphore mutex = 1;semaphore sem = 0; int csem=0
public void op1( ) { P(mutex);
while (!C) { csem ++;
V(mutex);P(sem);P(mutex);
}S1;V(mutex);
}
public void op2( ) { P(mutex);
S2 ;if (csem>0){ csem --;
V(sem)}V(mutex);
}
Schema con attesa circolare
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
26
Struttura dati della risorsa Rsemaphore mutex = 1;semaphore sem = 0; int csem = 0;
public void op1( ) { P(mutex);
if (!C) {csem ++;V(mutex);P(sem);csem --;
}S1;V(mutex);
}
public void op2( ) { P(mutex);
S2;if(csem>0)
V(sem);else V(mutex);
}
Schema con passaggio di testimone
14
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
27
• Il secondo schema è più efficiente del primo, ma consente di risvegliare un solo processo alla volta poichè ad uno solo può passare il diritto di operare in mutua esclusione.
• La condizione C verificata all’interno di op1 deve essere verificabile anche all’interno di op2. ciò significa che non deve contenere variabili locali o parametri della funzione op1.
Semafori condizione:considerazioni sulle soluzioni
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
28
Esempio di uso di semafori condizione: Gestione di un pool di risorse equivalenti
Si consideri un insieme (pool) di N risorse tutte uguali:• Ciascun processo può operare su una qualsiasi
risorsa del pool purché libera.• Necessità di un gestore che mantenga aggiornato lo
stato delle risorse.• Ciascun processo quando deve operare su una
risorsa chiede al gestore l’allocazione di una di esse.• Il gestore assegna al processo una risorsa libera (se
esiste), in modo dedicato, passandogli l’indice relativo.
• Il processo opera sulla risorsa senza preoccuparsi della mutua esclusione.
• Al termine il processo rilascia la risorsa al gestore.
15
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
29
int richiesta(): region G <<when (<ci sono risorse disponibili>) <scelta di una risorsa disponibile>;int i = <indice della risorsa scelta>;<registra che la risorsa di indice i non è più disponibile>;return i;>>
void rilascio(int r): region G <<<registra che la risorsa r-esima è di nuovo disponibile>>>
Gestione di un pool di risorse equivalenti: operazioni del gestore
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
30
class tipo_gestore{ semaphore mutex = 1; /*sem. di mutua esclusione*/
semaphore sem = 0; /*semaforo condizione*/int csem = 0; /*contatore dei proc. sospesi su sem */boolean libera[N]; /*indicatori di risorsa libera*/int disponibili = N; /*contatore risorse libere*//*inizializzazione:*/{for(int i=0; i < N; i++)libera[i]=true;} public int richiesta() { int i=0;
P(mutex);if (disponibili == 0) { csem ++;
V(mutex);P(sem):csem --; }
while(!libero[i]) i++;libero[i]=false;disponibili --;V(mutex);return i;
} /* continua..*/
Realizzazione:
16
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
31
public void rilascio (int r) { P(mutex);
libero[r]=true;disponibili ++;if (csem>0) V(sem);else V(mutex);
}} /* fine classe tipo_gestore */
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
32
tipo_gestore G; /* def. gestore*/
/*struttura del generico processo che vuole accedere a una risorsa del pool: */process P{
int ris;...ris = G.richiesta( );< uso della risorsa di indice ris>G.rilascio (ris) ;...
}
17
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
33
Semafori risorsa
• Semafori generali. Possono assumere qualunque valore = 0.
• Esempio: gestione di un pool di risorse equivalenti.• Unico semaforo n_ris inizializzato con un valore
uguale al numero di risorse da allocare.
• Esecuzione di P(n_ris) in fase di allocazione e di V(n_ris) in fase di rilascio
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
34
class tipo_gestore {semaphore mutex = 1; /*semaforo di mutua esclusione*/semaphore n_ris = N; /*semaforo risorsa*/boolean libera[N]; /*indicatori di risorsa libera*/
{for(int i=0; i < N; i++)libera[i]=true;} /*inizializzazione*/
public int richiesta() {int i=0;P(n_ris);P(mutex);while(libero[i]==false) i++;libero[i]=false;V(mutex);return i; }
public void rilascio (int r) {P(mutex);libero[r]=true;V(mutex);V(n_ris); }
}
18
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
35
Buffer strutturato come una coda di elementi di tipo T:
coda_di_n_T buffer;semaphore pn = 0;semaphore vu = n;semaphore mutex = 1;
void invio(T dato) { T ricezione() {P(vu); T dato;P(mutex); P(pn);buffer.inserisci(dato); P(mutex);V(mutex); dato =
buffer.estrai();V(pn); V(mutex);
} V(vu);return dato; }
Semafori risorsa: problema dei produttori/consumatori
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
36
Realizzazione del buffer: coda circolare.
class coda_di_n_T {T vettore[n];int primo = 0; ultimo = 0;public void inserisci(T dato) {
vettore[ultimo] = dato;ultimo = (ultimo+1)%n;
}
public T estrai( ) { T dato= vettore[primo];primo = (primo+1)%n;return dato;
} }
19
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
37
Semafori privati: specifica di strategie di allocazione
Condizione di sincronizzazione:Qualora si voglia realizzare una determinata politica di gestione delle risorse, la decisione se ad un dato processo sia consentito proseguire l'esecuzione dipende dal verificarsi di una condizione, detta condizione di sincronizzazione.
• La condizione è espressa in termini di variabili che rappresentano lo stato della risorsa e di variabili locali ai singoli processi.
• Più processi possono essere bloccati durante l’accesso ad una risorsa condivisa, ciascuno in attesa che la propria condizione di sincronizzazione sia verificata.
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
38
• In seguito alla modifica dello stato della risorsa da parte di un processo, le condizioni di sincronizzazione di alcuni processi bloccati possono essere contemporaneamente verificate.
Problema: quale processo mettere in esecuzione (accesso alla risorsa mutuamente esclusivo)? è Definizione di una politica per il risveglio dei processi
bloccati.
• Nei casi precedenti la condizione di sincronizzazione era particolarmente semplificata (vedi mutua esclusione) e la scelta di quale processo riattivare veniva effettuata tramite l’algoritmo implementato nella V.
• Normalmente questo algoritmo, dovendo essere sufficientemente generale ed il più possibile efficiente, coincide con quello FIFO.
20
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
39
• Su un buffer da N celle di memoria più produttori possono depositare messaggi di dimensione diversa.
Politica di gestione: tra più produttori ha priorità di accesso quello che fornisce il messaggio di dimensione maggiore.è finché un produttore il cui messaggio ha dimensioni
maggiori dello spazio disponibile nel buffer rimane sospeso, nessun altro produttore può depositare un messaggio anche se la sua dimensione potrebbe essere contenuta nello spazio libero del buffer.
Condizione di sincronizzazione: il deposito può avvenire se c’è sufficiente spazio per memorizzare il messaggio e non ci sono produttori in attesa.
Esempio 1Si
stem
iOpe
rati
viLS
–A
.A. 2
006-
2007
40
Il prelievo di un messaggio da parte di un consumatore prevede la riattivazione tra i produttori sospesi, di quello il cui messaggio ha la dimensione maggiore, semprechèesista sufficiente spazio nel buffer.
Se lo spazio disponibile non è sufficiente nessun produttore viene riattivato.
21
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
41
• Un insieme di processi utilizza un insieme di risorse comuni R1,R2,..Rn. Ogni processo può utilizzare una qualunque delle risorse.
Condizione di sincronizzazione: l'accesso e` consentito se esiste una risorsa libera.
• A ciascun processo è assegnata una priorità.
• In fase di riattivazione dei processi sospesi viene scelto quello cui corrisponde la massima priorità
Esempio 2Si
stem
iOpe
rati
viLS
–A
.A. 2
006-
2007
42
• Con riferimento al problema dei lettori & scrittori, si intende realizzare una politica di gestione che eviti condizioni di attesa indefinita (starvation) per entrambe le classi di processi.
Esempio 3
22
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
43
SEMAFORO PRIVATO
Un semaforo s si dice privato per un processo quando solo tale processo può eseguire la primitiva P sul semaforo s.
La primitiva V sul semaforo può essere invece eseguita anche da altri processi.
Un semaforo privato viene inizializzato con il valore zero.
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
44
Uso dei semafori privati
I semafori privati possono essere utilizzati per realizzareparticolari politiche di allocazione di risorse:– il processo che acquisisce la risorsa puo` (se la
condizione di sincronizzazione non e` soddisfatta) eventualmente sospendersi sul suo semaforoprivato
– chi rilascia la risorsa, risvegliera` uno tra i processisospesi (in base alla politica scelta) mediante unaV sul semaforo privato del processo prescelto.
23
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
45
class tipo_gestore_risorsa{<struttura dati del gestore>;semaphore mutex =1;semaphore priv[n] = {0,0,..0}; /*semafori privati*/
public void acquisizione (int i) { P(mutex);
if(<condizione di sincronizzazione>){<allocazione della risorsa>;V(priv[i]);
}else
<registrare la sospensione del processo>;V(mutex);P(priv[i]);
}
Allocazione di risorse: primo schemaSi
stem
iOpe
rati
viLS
–A
.A. 2
006-
2007
46
public void rilascio( ) { int i;
P(mutex); <rilascio della risorsa>;if (<esiste almeno un processo sospeso per
il quale la condizione di sincronizz. è soddisfatta>)
{ <scelta (fra i processi sospesi) del processo Pi da riattivare>;<allocazione della risorsa a Pi>;<registrare che Pi non è più sospeso>;V(priv[i]);
}V (mutex);
} }
24
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
47
Proprietà della soluzione:
a) La sospensione del processo, nel caso in cui la condizione di sincronizzazione non sia soddisfatta, non può avvenire entro la sezione critica in quanto ciò impedirebbe ad un processo che rilascia la risorsa di accedere a sua volta alla sezione critica e di riattivare il processo sospeso.
La sospensione avviene al di fuori della sezione critica.
b) La specifica del particolare algoritmo di assegnazione della risorsa non è opportuno che sia realizzata nella primitiva V. Nella soluzione proposta è possibile programmare esplicitamente tale algoritmo scegliendo in base ad esso il processo da attivare ed eseguendo V sul suo semaforo privato.
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
48
Lo schema presentato può, in certi casi, presentare degli inconvenienti.
1. l’operazione P sul semaforo privato viene sempre eseguita anche quando il processo richiedente non deve essere bloccato.
2. Il codice relativo all’assegnazione della risorsa viene duplicato nelle procedure acquisizione e rilascio
èSi può definire uno schema che non ha questi inconvenienti.
25
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
49
class tipo_gestore_risorsa{<struttura dati del gestore>;semaphore mutex = 1;semaphore priv[n] = {0,0,..0}; /*semafori privati */
public void acquisizione (int i) { P(mutex);
if(! <condizione di sincronizzazione>){ <registrare la sospensione del processo>;V(mutex);P(priv[i]);<registrare che il processo non è più sospeso>;
}<allocazione della risorsa>;V(mutex);
}
Allocazione di risorse: secondo schemaSi
stem
iOpe
rati
viLS
–A
.A. 2
006-
2007
50
public void rilascio( ) { int i;
P(mutex); <rilascio della risorsa>;if (<esiste almeno un processo sospeso per
il quale la condizione di sincronizz. è soddisfatta>)
{ <scelta del processo Pi da riattivare>;V(priv[i]);
}else V(mutex);
}}
26
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
51
A differenza della soluzione precedente, tuttavia, in questo caso risulta più complesso realizzare la riattivazione di più processi per i quali risulti vera contemporaneamente la condizione di sincronizzazione.
Lo schema prevede infatti che il processo che rilascia la risorsa attivi al più un processo sospeso, il quale dovrà a sua volta provvedere alla riattivazione di eventuali altri processi.
CommentoSi
stem
iOpe
rati
viLS
–A
.A. 2
006-
2007
52
class buffer {int richiesta[num_proc]=0;/*richiesta[i]= numero di
celle richieste da Pi*/int sospesi=0; /*numero dei processi prod.sospesi*/int vuote=n; /*numero di celle vuote del buffer*/semaphore mutex=1;semaphore priv[num_proc]={0,0,..0};
public void acquisizione(int m, int i) /* m dim. messaggio, i nome del processo chiamante */{ P(mutex);
if (sospesi==0 && vuote>=m) { vuote=vuote-m;
<assegnaz. di m celle al proc.i >;V(priv[i]);
}else{ sospesi++;
richiesta[i]=m;}V(mutex);P(priv[i]);
}
Soluzione ai problemi precedenti: esempio 1
27
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
53
public void rilascio(int m) /* m num. celle rilasciate*/ { int k;
P(mutex); vuote+=m;while (sospesi!=0) { <individuazione tra i processi sospesi del
processo Pk con la massima richiesta> ;if (richiesta[k]<=vuote) { vuote=vuote–richiesta[k];
<ass. a Pk delle celle richieste>;richiesta[k]=0;sospesi--;V(priv[k]);
}else break; /* fine while */
} V(mutex);
}}
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
54
Soluzione esempio 2
Soluzione: introduzione delle seguenti variabili:
• PS[i]: variabile logica che assume il valore vero se il processo Pi è sospeso; il valore falso diversamente.
• libera[j]: variabile logica che assume il valore falso se la risorsa j-esima è occupata; il valore vero diversamente.
• disponibili: esprime il numero delle risorse non occupate;
• sospesi: e` il numero dei processi sospesi;• mutex: semaforo di mutua esclusione• priv[i]: il semaforo privato del processo Pi.
28
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
55
class tipo_gestore {semaphore mutex=1;semaphore priv[num_proc]={0,0,…0} /*sem. privati */int sospesi=0; /*numero dei processi sospesi*/boolean PS[num_proc]={false, false,…, false}; int disponibili=num_ris; /*numero di risorse disp.*/boolean libera[num_ris]={true, true,…, true}; public int richiesta(int proc) { int i =0;
P(mutex); if (disponibili==0) { sospesi ++;
PS[proc]=true;V(mutex);P(priv[proc]);PS[proc]=false;sospesi -- ;
}while (! libera[i]) i++;libera[i]=false;disponibili--;V(mutex );return i;
}
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
56
public void rilascio (int r)/* r indice risorsa ril. */ { P(mutex);
libera[r]=true; disponibili++;if (sospesi>0) { <seleziona il processo Pj a massimapriorità tra quelli sospesi utilizzando PS>;V(priv[j]);
}else V(mutex);
}}
29
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
57
• Ogni processo che nella fase di acquisizione della risorsa trova la condizione di sincronizzazione non soddisfatta, deve lasciare traccia in modo esplicito della sua sospensione entro la sezione critica.
• Il processo che libera la risorsa deve infatti eseguire la primitiva V(priv(i)) solo se esistono processi sospesi. In tutte le soluzioni è stata introdotta un’apposita variabile per indicare il numero dei processi sospesi.
• La fase di assegnazione di una risorsa ad un processo è separata dalla fase di uso della risorsa stessa.
• Occorre quindi lasciare traccia in modo esplicito entro la sezione critica della assegnazione e quindi della non disponibilità della risorsa. Nel primo esempio viene decrementata la variabile vuote; nel secondo viene modificata la variabile R.
Considerazioni sulle soluzioni presentateSi
stem
iOpe
rati
viLS
–A
.A. 2
006-
2007
58
Realizzazione dei semafori
vals ==0
vals --
no
si
P(s)
<cambio contesto>bloccatis>0
vals ++
si
no
V(s)
<sveglia processo>
30
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
59
Descrittore di un semaforo:typedef struct{
int contatore;coda_a_livelli coda;}des_semaforo;
Insieme di tutti i descrittori:des_semaforo semafori[num_max_sem];
Identificazione di un semaforo:typedef int semaphore;
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
60
Implementazione dell'operazione P:
void P(semaphore s){ p_des esec = processo_in_esecuzione;
int pri= esec -> servizio.priorità; if(semafori[s].contatore==0) { esec -> stato = < “sospeso sul semaforo s”>;
inserimento (esec,semafori[s].coda[pri]);assegnazione_CPU;
}else contatore--;
}
Ambiente monoprocessore
31
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
61
Implementazione dell'operazione V:
void V (semaphore s) { p_des esec = processo_in_esecuzione;
p_des p;int pri=0;while(semafori[s].coda[pri].primo==NULL &&
pri < min_priorità)pri++;
if(semafori[s].coda[pri].primo!=NULL) { p=prelievo(semafori[s].coda[pri])
attiva(p);}else semafori[s].contatore ++;
}
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
62
boolean test_and_set( boolean *a) { boolean test=*a;
*a=true;return test;
}
void lock(boolean * x) { while (test_and-set(x));}
void unlock(boolean * x) { x=false;}
Ambiente multiprocessore
32
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
63
x=false x ==true
x=true
no
si
unlock(x) lock(x)
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
64
Strumenti di sincronizzazione nella libreriaLinuxThread e nel linguaggio Java
33
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
65
I semafori nelle librerie pthread e LinuxThreads
• La libreria pthread definisce soltanto il semaforobinario (mutex).
• La Libreria Linuxthread, implementa comunque ilsemaforo esternamente alla libreria pthread, conformemente allo standard POSIX 1003.1b
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
66
pthread: MUTEX
• Lo standard POSIX 1003.1c (libreria <pthread.h>) definisce i semafori binari (o lock, mutex, etc.)– sono semafori il cui valore puo` essere 0 oppure 1 (occupato o
libero);– vengono utilizzati tipicamente per risolvere problemi di mutua
esclusione– operazioni fondamentali:
• inizializzazione: pthread_mutex_init• locking: pthread_mutex_lock• unlocking: pthread_mutex_unlock
– Per operare sui mutex:pthread_mutex_t : tipo di dato associato al mutex; esempio:
pthread_mutex_t mux;
34
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
67
• L'inizializzazione di un mutex si puo`realizzare con:
int pthread_mutex_init(pthread_mutex_t* mutex, const pthread_mutexattr_t* attr)
attribuisce un valore iniziale all'intero associato al semaforo (default: libero):• mutex : individua il mutex da inizializzare• attr : punta a una struttura che contiene gli attributi del
mutex; se NULL, il mutex viene inizializzato a libero (default).
– in alternativa , si puo` inizializzare il mutex a default con lamacro:
PTHREAD_MUTEX_INIZIALIZER
– esempio: pthread_mutex_t mux= PTHREAD_MUTEX_INIZIALIZER ;
MUTEX: inizializzazione Si
stem
iOpe
rati
viLS
–A
.A. 2
006-
2007
68
• Locking/unlocking si realizzano con:
int pthread_mutex_lock(pthread_mutex_t* mux) int pthread_mutex_unlock(pthread_mutex_t* mux)
– lock: se il mutex mux e` occupato,il thread chiamante si sospende; altrimenti occupa il mutex.
– unlock: se vi sono processi in attesa del mutex, ne risveglia uno; altrimenti libera il mutex.
MUTEX: lock/unlock
35
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
69
Esempio#include <stdio.h>#include <stdlib.h>#include <pthread.h>#define MAX 10pthread_mutex_t M; /* def.mutex condiviso tra threads */int DATA=0; /* variabile condivisa */int accessi1=0; /*num. di accessi del thread 1 alla sez critica */int accessi2=0; /*num. di accessi del thread 2 alla sez critica */
void *thread1_process (void * arg){ int k=1;
while(k){
pthread_mutex_lock(&M); /*prologo */accessi1++;DATA++;k=(DATA>=MAX?0:1);printf("accessi di T1: %d\n", accessi1);pthread_mutex_unlock(&M); /*epilogo */
}pthread_exit (0);
}
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
70
Esempio
void *thread2_process (void * arg){ int k=1;
while(k){
pthread_mutex_lock(&M); /*prologo sez. critica */accessi2++;DATA++;k=(DATA>=MAX?0:1);printf("accessi di T2: %d\n", accessi2);pthread_mutex_unlock(&M); /*epilogo sez. critica*/
}pthread_exit (0);
}
36
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
71
Esempio:
main(){ pthread_t th1, th2;/* il mutex e` inizialmente libero: */pthread_mutex_init (&M, NULL); if (pthread_create(&th1, NULL, thread1_process, NULL) < 0)
{ fprintf (stderr, "create error for thread 1\n");exit (1);
}if (pthread_create(&th2, NULL,thread2_process,NULL) < 0){ fprintf (stderr, "create error for thread 2\n");exit (1);
}pthread_join (th1, NULL);pthread_join (th2, NULL);
}
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
72
Test
$$ gcc -D_REENTRANT -o tlock lock.c -lpthread$ ./tlockaccessi di T2: 1accessi di T1: 1accessi di T2: 2accessi di T1: 2accessi di T1: 3accessi di T1: 4accessi di T1: 5accessi di T1: 6accessi di T1: 7accessi di T1: 8accessi di T2: 3$
37
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
73
LinuxThreads: Semafori
• Memoria condivisa: uso dei semafori (POSIX.1003.1b)– Semafori: libreria <semaphore.h>
• sem_init: inizializzazione di un semaforo
• sem_wait: implementazione di P
• sem_post: implementazione di V
– sem_t : tipo di dato associato al semaforo; esempio:
static sem_t my_sem;
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
74
Operazioni sui semafori– sem_init: inizializzazione di un semaforoint sem_init(sem_t *sem, int pshared, unsigned int value)
attribuisce un valore iniziale all'intero associato al semaforo:
• sem: individua il semaforo da inizializzare• pshared : 0, se il semaforo non e` condiviso tra task, oppure non
zero (sempre zero).• value : e` il valore iniziale da assegnare al semaforo.
– sem_t : tipo di dato associato al semaforo; esempio:
static sem_t my_sem;
Ø ritorna sempre 0.
38
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
75
Operazioni sui semafori: sem_wait
– wait su un semaforoint sem_wait(sem_t *sem)
dove: • sem: individua il semaforo sul quale operare.
e` la wait di Dijkstra:Ø se il valore del semaforo e` uguale a zero, sospende il thread chiamante
nella coda associata al semaforo; altrimenti ne decrementa il valore.
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
76
Operazioni sui semafori: sem_post
– signal su un semaforo:int sem_post(sem_t *sem)
dove: • sem: individua il semaforo sul quale operare.
e` la signal di Dijkstra:Ø se c'e` almeno un thread sospeso nella coda associata al semaforo sem,
viene risvegliato; altrimenti il valore del semaforo viene incrementato.
39
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
77
Esempio: sincronizzazione
Ø Imposizione di un vincolo temporale: la FASE2 nel thread 1 va eseguita dopo la FASE1 nel thread2.
Thread 1 Thread 2
Fase 1
Fase 2
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
78
Esempio: sincronizzazione/* la FASE2 nel thread 1 va eseguita dopo la FASE1 nel thread 2*/#include <stdio.h>#include <stdlib.h>#include <pthread.h>#include <semaphore.h>
sem_t my_sem;int V=0;
void *thread1_process (void * arg){ printf ("Thread 1: partito!...\n");/* inizio Fase 2: */sem_wait (&my_sem);printf ("FASE2: Thread 1: V=%d\n", V);pthread_exit (0);
}
40
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
79
void *thread2_process (void * arg){ int i;
V=99;printf ("Thread 2: partito!...\n);/* inizio fase 1: */ printf (“FASE1: Thread 2: V=%d\n", V);/* …termine Fase 1: sblocco il thread 1*/sem_post (&my_sem);sleep (1);
pthread_exit (0);}
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
80
main (){ pthread_t th1, th2;void *ret;sem_init (&my_sem, 0, 0); /* semaforo a 0 */
if (pthread_create (&th1, NULL, thread1_process, NULL) < 0) { fprintf (stderr, "pthread_create error for thread 1\n");exit (1);
}
if (pthread_create(&th2,NULL, thread2_process, NULL) < 0) {fprintf (stderr, "pthread_create error for thread \n");exit (1);
}
pthread_join (th1, &ret);pthread_join (th2, &ret);
}
41
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
81
Esempio:
• gcc -D_REENTRANT -o sem sem.c –lpthread
• Esecuzione:[aciampolini@ccib48 threads]$ semThread 1: partito!...Thread 2: partito!...FASE1: Thread 2: V=99FASE2: Thread 1: V=99[aciampolini@ccib48 threads]$
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
82
Semafori: esempio
/* tre processi che, ciclicamente, incrementano a turno (in ordine P1,P2,P3) la variabile V*/
#include <stdio.h>#include <stdlib.h>#include <pthread.h>#include <semaphore.h>#define MAX 13static sem_t m; /* semaforo per la mutua esclusione
nell’accesso alla sezione critica */static sem_t s1,s2,s3; /* semafori per imporre
l’ordine di accesso (P1,P2,P3) alla variabile V */
int V=0,F=0;
42
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
83
void *thread1_process (void * arg){ int k=1;
while(k){ sem_wait (&s1);
sem_wait(&m);if (V<MAX)
V++;else{ k=0;
printf("T1: %d (V=%d)\n",++F, V);}sem_post(&m);sem_post(&s2);
}pthread_exit (0);
}
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
84
void *thread2_process (void * arg){ int k=1;
while(k){ sem_wait (&s2);
sem_wait(&m);if (V<MAX)
V++;else{ k=0;
printf("T2: %d (V=%d)\n",++F, V);}sem_post(&m);sem_post(&s3);
}pthread_exit (0);
}
43
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
85
void *thread3_process (void * arg){ int k=1;
while(k){ sem_wait (&s3);
sem_wait(&m);if (V<MAX)
V++;else{ k=0;
printf("T3: %d (V=%d)\n",++F, V);}sem_post(&m);sem_post(&s1);
}pthread_exit (0);
}
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
86
main (){ pthread_t th1, th2,th3;
sem_init (&m, 0, 1);sem_init(&s1,0,1);sem_init(&s2,0,0);sem_init(&s3,0,0);if (pthread_create(&th1, NULL, thread1_process, NULL) < 0) { fprintf (stderr, "pthread_create error for thread 1\n");exit (1);
}if (pthread_create(&th2, NULL,thread2_process,NULL) < 0) { fprintf (stderr, "pthread_create error for thread 2\n");exit (1);
}if (pthread_create(&th3,NULL,thread3_process, NULL) < 0) { fprintf (stderr, "pthread_create error for thread 3\n");exit (1);
}
44
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
87
pthread_join (th1, NULL);pthread_join (th2, NULL);pthread_join (th3, NULL);
}
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
88
Sincronizzazione in Java
Modello a memoria comune:I threads di una applicazione condividono lo spazio di indirizzamento.
èOgni tipo di interazione tra thread avviene tramite oggetti comuni:– Interazione di tipo competitivo (mutua
esclusione): meccanismo degli objects locks.– Interazione di tipo cooperativo:
• meccanismo wait-notify.• variabili condizione
45
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
89
Semafori in Java
• Non esiste una classe che implementi i semafori. E` possibile implementarli sfruttando altri strumenti disincronizzazione (ad es. wait/notify, VariabiliCondizione).
• Il linguaggio prevede costrutti specifici per risolvere ilproblema della mutua esclusione:– statement syncronized
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
90
Mutua esclusione
• Ad ogni oggetto viene associato dalla JVM un lock(analogo ad un semaforo binario).
• E’ possibile denotare alcune sezioni di codice che operano su un oggetto come sezioni critiche tramite la parola chiave synchronized.
èIl compilatore inserisce :– un prologo in testa alla sezione critica per
l’acquisizione del lock associato all’oggetto.– un epilogo alla fine della sezione critica per
rilasciare il lock.
46
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
91
Blocchi synchronizedCon riferimento ad un oggetto x si può definire un blocco di statement come una sezione critica nel seguente modo (synchronized blocks):
synchronized (oggetto x) {<sequenza di statement>;}
Esempio:Object mutexLock= new Object;
…..public void M( ) {
<sezione di codice non critica>;synchronized (mutexlock){< sezione di codice critica>;}
<sezione di codice non critica>;}
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
92
• all'oggetto mutexLock viene implicitamente associato un lock, il cui valore puo` essere:– libero: il thread può eseguire la sezione critica– occupato: il thread viene sospeso dalla JVM in
una coda associata a mutexLock (entry set).
Al termine della sezione critica:– se non ci sono thread in attesa: il lock viene reso
libero .– se ci sono thread in attesa: il lock rimane occupato
e viene scelto uno di questi .
47
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
93
synchronized block
• esecuzione del blocco mutuamente esclusivarispetto:– ad altre esecuzioni dello stesso blocco– all’esecuzione di altri blocchi sincronizzati sullo
stesso oggetto
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
94
lock
Object ob
synchronized (ob){………… ;
}t1
a) lock libero
lock
Object ob
synchronized (ob){………… ;
} t1
a) lock occupato: t2e t3 vengono inseriti nell'entry set di ob
t2
t3
Entry set di un oggetto
48
Sist
emiO
pera
tivi
LS –
A.A
. 200
6-20
07
95
Metodi synchronized
• Mutua esclusione tra i metodi di una classepublic class intVar {private int i=0;public synchronized void incrementa() { i ++; }public synchronized void decrementa() {i--; }}
• Quando un metodo viene invocato per operare su un oggetto della classe, l’esecuzione del metodo avviene in mutua esclusione utilizzando il lockdell’oggetto.