Condivisione. Sistemi Operativi Giuseppe Prencipe. Es.: produttore -- consumatore. Es.: produttore -- consumatore. Es.: produttore -- consumatore

Transcript

1 Sistemi Operativi Giuseppe Prencipe Sincronizzazione dei Processi Condivisione I processi di un SO possono cooperare Tipicamente condividono dati e file Si rendono necessari meccanismi che garantiscano la coerenza dei dati, quando vengono utilizzati da diversi processi 1 2 Es.: produttore -- consumatore while (1) { while (((inserisci+1)%dim_vettore == preleva); vettore[inserisci]=appena_prodotto; inserisci=(inserisci+1)%dim_vettore; Supponiamo di voler utilizzare un while (1) { contatore while (inserisci==preleva); condiviso...???? da_consumare=vettore[preleva]; preleva=(preleva+1)%dim_vettore; 3 Es.: produttore -- consumatore while (1) { while (contatore==dim_vettore); vettore[inserisci]=appena_prodotto; inserisci=(inserisci+1)%dim_vettore; contatore++; while (1) { while (contatore==0); da_consumare=vettore[preleva]; preleva=(preleva+1)%dim_vettore; contatore--; Problemi???? Cosa succede se contatore++ e contatore-- sono eseguite concorr.? Qual è il valore finale di contatore? 4 Es.: produttore -- consumatore Come sono codificate a livello macchina le due istruzioni? contatore++: registro1:=contatore; registro1:=registro1+1; contatore:=registro1; contatore--: registro2:=contatore; registro2:=registro2-1; contatore:=registro2; Quali sono i possibili valori finali di contatore (interleaving!!)? Es.: produttore -- consumatore Inizio: contatore = 5. Una possibile sequenza di interleaving è: produttore: registro1 = contatore (registro1 = 5) produttore: registro1 = registro1 + 1 (registro1 = 6) consumatore: registro2 = contatore (registro = 5) consumatore: registro2 = registro2 1 (registro2 = 4) produttore: counter = registro1 (contatore = 6) consumatore: counter = registro2 (contatore = 4) Il valore di contatore può essere 4 o 6, ma quello corretto è 5! Necessario sincronizzare e coordinare i processi!!!! 5 6 1

2 Sezione critica Sezione critica: segmento di codice in cui un processo agisce su dati condivisi Deve essere eseguito in mutua esclusione Tipicamente si hanno Sezione d ingresso: il processo chiede il permesso di poter eseguire la Sezione critica Sezione d uscita Sezione non critica 7 Sezione critica Mutua esclusione con sezioni critiche 8 Sezione critica Il problema della si risolve tramite un protocollo che i processi usano per cooperare Deve soddisfare 3 requisiti Mutua esclusione Progresso: la scelta del processo da far entrare in SC non può essere rimandata indefinitamente e nessun processo fuori dalla propria sezione critica può bloccare altri processi Attesa limitata: un processo attende un tempo limitato tra quando richiede di entrare in SC e quando il permesso gli viene accordato 9 Sezione critica Normale assunzione: le istruzioni di base del linguaggio macchina (load, store, ecc.) sono eseguite in modo atomico La struttura generale di un tipico processo è sezione d ingresso sezione d uscita while (1); 10 2 processi: Algoritmo 1 Variabile turno inizializzata a 0 (o a 1) Mutua esclusione? Progresso? Problema: non si ricordano info sufficienti sullo stato di un processo... P0 while (turno!= 0); turno = 1; while(1); 11 2 processi: Algoritmo 2 Vettore bool pronto[2] inizializzato a [F,F] Mutua esclusione? Progresso? Problema: dipende dalla temporizzazion e dei due processi... P0 pronto[0] = T; while (pronto[1]); pronto[0] = F; while(1); 12 2

3 2 processi: Algoritmo 2...e invertendo le istruzioni? Mutua esclusione? while (pronto[1]); Progresso? pronto[0] = T; P0 pronto[0] = F; while(1); 13 2 processi: Algoritmo 3 (Peterson) Usiamo sia turno che pronto[2]... Mutua esclusione? pronto[0] = T; Progresso? turno = 1; while (pronto[1] && Attesa limitata? P0 turno == 1); pronto[0] = F; while(1); 14 Implementazione alg. Peterson Più processi (algoritmo del fornaio) Per n processi Prima di entrare nella SC, un processo riceve un numero. Il possessore del numero più piccolo entra in SC Se processi P i e P j ricevono lo stesso numero, se i < j, allora P i viene servito prima; altrimenti P j I numeri vengono generati sequenzialmente e in ordine crescente: 1,2,3,3,3,3,4, Algoritmo del fornaio Notazione: < ordine lessicografico (a,b) < (c,d) se a < c o if a = c e b < d max(a 0,, a n-1 ) è un numero k tale che: k a i per i = 0,, n 1 Dati comuni boolean choosing[n]; int number[n]; Strutture dati inizializzate a false e 0 rispettivamente Algoritmo del fornaio Processo P i choosing[i] = true; number[i] = max(number[0], number[1],,number[n 1])+1; choosing[i] = false; for (j = 0; j < n; j++) { while (choosing[j]); while ((number[j]!= 0) && ((number[j],j) < (number[i],i)); number[i] = 0; while (1);

4 Algoritmo del fornaio Per provarne la correttezza, bisogna dimostrare: Se P i si trova in SC e P k ha già scelto il proprio numero, allora (number[i],i) < (number[k],k) (Es. 7.3 sul libro di testo) Mutua esclusione Progresso Attesa limitata 19 Architetture di sincronizzazione Molto spesso si utilizzano caratteristiche dell hardware per risolvere più semplicemente il problema della SC Es.: Se P i entra in SC, disabilita gli interrupt Non va bene, specie in sistemi multi-processore (sprechi di tempo per trasmettere la richiesta di disabilitazione a tutte le CPU) Alternativa: istruzioni per leggere e modificare il contenuto di una parola di memoria in modo atomico boolean TestAndSet(boolean &target) { boolean rv = target; target = true; return rv; Atomica: se due T&S eseguite su CPU diverse, vengono eseguite sequenzialmente (ordine arbitrario) 20 Mutua Esclusione con Test-and-Set Dato condiviso boolean lock = false; Process P i while (TestAndSet(lock)) ; lock = false; while (1); 21 Sincronizzazione Hardware swap atomico di due variabili void Swap(boolean &a, boolean &b) { boolean temp = a; a = b; b = temp; 22 Mutua Esclusione con swap Dato condiviso boolean lock=false; Processo P i : key = true; while (key == true) { Swap(lock,key); critical section lock = false; remainder section Attesa limitata? 23 Mutua Esclusione con Test-and-Set e attesa limitata Dati condivisi: boolean waiting[n] = {false, lock = false; Processo P i : int j; boolean key; waiting[i] = true; key = true; while (waiting[i] && key) key=testandset (lock); waiting[i] = false; j = i+1 % n; while ((j!= i) && (not waiting[j])) {j=j+1 % n; if (j=i) lock=false; else waiting[j]= false; while (1); 24 4

5 Semafori Un altro strumento di sincronizzazione è il semaforo Semaforo S variabile intera Si accede solo tramite due operzioni atomiche wait (S): while S 0 do no-op; S--; signal (S): S++; Originariamente chiamate P (proberen -- verificare) e V (verhogen -- incrementare) Sezione critica di n processi Dato condiviso: semaphore mutex; /* mutex = 1 */ Processo P i : wait(mutex); signal(mutex); while (1); Attesa attiva (busy waiting) Sia P i nella sua SC Sia P k nella sua sezione d ingresso P k attende di entrare nella sua SC, e si trova nel ciclo della sezione d ingresso Questa è attesa attiva: spreco di cicli CPU Utili in sistemi con più CPU, in quanto non vengono effettuati cambi di contesto (va bene solo per attese brevi) Si presenta in tutte le soluzioni viste per il problema della SC 27 Implementazione dei semafori Un processo che esegue una wait e deve attendere, si blocca (va in una coda associata al semaforo) Quando viene eseguita una signal, si riattiva uno dei processi interessati Si definisce il semaforo come un record typedef struct { int value; struct process *L; /* lista di processi */ semaphore; Ci sono due operazioni: block sospende il processo che la invoca wakeup(p) riattiva l esecuzione del processo bloccato P block e wakeup(p) sono chiamate di sistema 28 Implementazione Le operazioni sui semafori ora sono wait(s): S.value--; if (S.value < 0) { aggiungi questo processo a S.L; block; signal(s): S.value++; if (S.value <= 0) { rimuovi un processo P da S.L; wakeup(p); 29 Implementazione wait e signal devono essere eseguite in modo atomico Con una sola CPU è sufficiente disabilitare le interruzioni Con più CPU, si possono usare una delle soluzioni al problema della sezione critica viste in precedenza (vedendo wait e signal come sezioni critiche) 30 5

6 Semafori come strumento di sincronizzazione generale Eseguire B in P j solo dopo che A è stato eseguito in P i Si usa un semaforo flag inizializzato a 0 P i M A signal(flag) P j M wait(flag) B 31 Stallo e attesa indefinita (deadlock e starvation) Deadlock 2 o più processi aspettano indefinitamente un evento che può essere causato solo da uno sei processi in attesa Siano S e Q due semafori inizializzati a 1 P 0 P 1 wait(s) critical section wait(q) critical section wait(q) Q.L = {P 0 wait(s) S.L = {P 1 M M signal(s) Stallo signal(q) Starvation attesa indefinita. Un processo può non venire mai rimosso dalla coda di un semaforo (ex. LIFO) 32 Due tipi di semafori Semaforo contatore il suo valore intero varia in un dominio logicamente non limitato Semaforo binario il suo valore intero può essere solo 0 o 1 Si può implementare un semaforo contatore con semafori binari Implementare un semaforo cont. con semaforo binario Sia S il semaforo contatore da realizzare Strutture dati: binary-semaphore S1, S2; int C: Inizializzazione: S1 = 1 S2 = 0 C = valore iniziale di S Implementare S Esercizio: provate a scrivere wait(s) e signal(s) in termini di S1 e S2 Implementare S wait wait(s1); C--; if (C < 0) { signal(s1); wait(s2); signal(s1); 35 signal wait(s1); C ++; if (C <= 0) signal(s2); else signal(s1); 36 6

7 Classici problemi di sincronizzazione Produttori e consumatori con memoria limitata Problema dei lettori e degli scrittori Problema dei filosofi a cena Prod e consum con memoria limitata Dati condivisi semaphore full, empty, mutex; Inizio: Le soluzioni presentate utilizzano semafori 37 full = 0, empty = n, mutex = 1 38 Produttore (con memoria limitata) produci elemento nextp wait(empty); wait(mutex); aggiungi nextp al buffer signal(mutex); signal(full); while (1); Consumatore (con memoria limitata) wait(full) wait(mutex); metti un elem dal buffer in nextc signal(mutex); signal(empty); consuma l elem in nextc while (1); Problema dei lettori e degli scrittori Si consideri un insieme di dati (ad es. Un file) condivisi fra vari processi concorrenti Alcuni processi possono richiedere solo la lettura, altri posso richiederne un aggiornamento (lettura+scrittura) Questi due tipi di processi sono distinti (lettori e scrittori) Due lettori possono accedere contemporaneamente ai dati, ma non uno scrittore e un altro processo!

8 Problema dei lettori e degli scrittori Ne esistono diverse varianti, tutte basate su vari tipi di priorità esistenti fra lettori e scrittori La prima: nessun lettore attenda, a meno che uno scrittore abbia già ottenuto il permesso di scrivere (cioè: nessun lettore attende altri lettori solo perchè uno scrittore attende) La seconda: uno scrittore, quando pronto, esegue la scrittora al più presto Le soluzioni a questi due problemi possono portare a attesa indefinita (primo caso: scrittori/ secondo caso: lettori). Quindi sono state proposte altre varianti Qui vediamo la soluzione al primo problema 43 Problema dei lettori e degli scrittori Dati condivisi: semaphore mutex, wrt; int readcount; /* wrt è comune a tutti i processi */ Inizio: mutex = 1, wrt = 1, readcount = 0 44 Scrittore wait(wrt); writing is performed signal(wrt); 45 Lettore Cosa succede quando uno scrittore è in SC e n lettori attendono di entrarvi? wait(mutex); readcount++; if (readcount == 1) wait(wrt); signal(mutex); reading is performed wait(mutex); readcount--; if (readcount == 0) signal(wrt); signal(mutex): 46 Problema dei filosofi a cena 5 filosofi a cena (processi) Filosofi mangiano/pensano Mangiare: 2 forchette (risorse) Prendi una forchetta alla volta Prevenire deadlock Dati condivisi: semaphore chopstick[5]; Inizio: tutti I valori a

9 Filosofi a cena Filosofo i: Stallo? Mutua esclusione? wait(chopstick[i]) wait(chopstick[(i+1) % 5]) eat signal(chopstick[i]); signal(chopstick[(i+1) % 5]); think while (1); Filosofi a cena (no stallo) = {0; Filosofi a cena (no stallo) cont. Regioni critiche con semafori -- problemi Invertire la posizione di wait e signal signal(mutex); no mutua esclusione wait(mutex); Due wait wait (mutex); deadlock wait (mutex); No signal wait (mutex); deadlock Starvation? Regione critica condizionale Per evitare questi problemi, sono stati introdotti costrutti di linguaggio ad alto livello Regione critica condizionale v: shared T; region v when (B) do S; Mentre si esegue S nessun altro processo può accedere a v. B è una condizione booleana Se B è vera, allora l acceso a v è consentito (in mutua esclusione) 53 Regione critica condizionale Produttore consumatore struct vettore { elemento gruppo[n] int contatore, inserisci, preleva; Produttore region vettore when (contatore<n) { gruppo[inserisci]=appena_prodotto; inserisci=(inserisci+1)%n; contatore++;; Consumatore region vettore when (contatore>0) { da_consumare=gruppo[preleva]; preleva=(preleva+1)%n; contatore--;; 54 9

10 Regione critica condizionale Il compilatore utilizza le seguenti variabili Semaphore mutex,primo_ritardo,secondo_ritardo; Inizio: 1,0,0 int primo_contatore, secondo_contatore; Inizio: 0,0 La mutua esclusione è garantita da mutex Se B è falsa, il processo attende su primo_ritardo. Prima di rivalutare B, il processo viene spostato su secondo_ritardo I contatori contano il numero di processi sui due semafori Realizzazione riportata in Fig Monitor Altro costrutto di sincronizzazione ad alto livello È caratterizzato da opertaori definiti dal programmatore È costituito da dichiarazioni di variabili, e di corpi di procedure o funzioni che realizzano gli operatori Monitor monitor nome_monitor { dich di variabili condivise procedure body P1(...) { procedure body P2(...) {... procedure body Pn(...) { {codice di inizializzazione Monitor Il monitor assicura che al suo interno sia attivo un solo processo alla volta (mutua esclusione) Per poter esprimere tutti gli schemi di sincronizzazione, sono necessarie le variabili condition condition x, y; Le operazioni eseguibili su variabili condition sono wait e signal x.wait() il processo che la invoca rimane sospeso fino a che un altro processo non invoca x.signal() se non ci sono processi in attesa di una signal, non succede nulla (a differenza della signal nei semafori) Monitor Produtore/consumatore con Monitor Problema: P invoca x.signal, e Q viene sbloccato da questa istruzione Quali fra P e Q deve proseguire? Se Q P deve attendere Se P Q deve attendere Ragionevole, dato che P è già in esecuzione. Ma sarà sempre valida la condizione attesa da Q quando Q andrà in esecuzione?

11 Filosofi a cena con monitor monitor fc { enum {pensa, affamato, mangia stato[5]; condition auto[5]; void prende(int i) { stato[i]=affamato; verifica(i); if (stato[i]!=mangia) auto[i].wait(); void pensa(int i) { stato[i]=pensa; verifica((i+4)%5); verifica((i+1)%5); void verifica(int i) { filosofo(i): fc.prende(i);... mangia... fc.posa(i) if ((stato[(i+4)%5]=!mangia)&&(stato[i]==affamato)&&(stato[(i+1)%5]!=mangia)){ stato[i]=mangia; auto[i].signal(); void init(){ for (int i=0;i<5;i++) stato[i]=pensa; 61 Monitor con semafori A ogni monitor si associa un semaforo mutex inizializzato a 1 wait(mutex) prima di entrare nel monitor e signal(mutex) all uscita Dato che un processo che esegue una signal (condition) deve attendere che il processo svegliato si metta in attesa o lasci il monitor si usa un semaforo prossimo (inizializzato a zero), su cui i processo che esguono signal si autosospendono prossimo_contatore conta i processi sospesi su prossimo Provate Monitor con semafori Ogni procedura F di un monitor diventa: wait (mutex)... corpo di F... if(prossimo_contatore > 0) signal(prossimo); else signal(mutex); Monitor con semafori Variabili condition Per ogni variabile condition x, si usa un semaforo x_sem e un contatore x_contatore (inizializzati a zero) Monitor con semafori x.wait: x_contatore++; if(prossimo_contatore > 0) signal(prossimo); else signal(mutex); wait(x_sem); x_contatore--; x.signal: if(x_contatore > 0) { prossimo_contatore++; signal(x_sem); wait(prossimo); prossimo_contatore++; 65 Monitor attesa condizionale Quando più processi sono sospesi su una condizione x, quando viene eseguita la x.signal, quale processo viene riattivato? Si ordinano i processi con coda FIFO Costrutto attesa condizionale x.wait(c), dove c è detto numero di priorità, e si memorizza col nome del processo sospeso Quando si esegue x.signal, si riprende il processo cui è associato il numero di priorità più basso 66 11

12 Monitor Java fornisce i monitor thread user-level ME nell esecuzione dei metodi synchronized di una stessa classe non ci sono variabili di condizione wait(), notify() simili a block(), wakeup() è possibile svegliare tutti i processi in attesa Vediamo di nuovo il problema del produttore e del consumatore 67 Per oggi basta!!!! 68 12