UniTO/anno2/Sem1/Galla/MCAD/lesson7-18102017.md

Semafori concorrenti - HHO

(scrivi il resto)

No deadlock

Per assurdo, supponiamo deadlock al tempo T: i semafori si bloccano su P (idrogeno su P(sH), ossigeno su uno dei P(sO))

• Invarianti semaforici

val(sH,T) = 0
=> NP(sO, T) = NV(s0,T) // nessuna P eseguita con successo, il valore di sH e' 0 perche' il processo e' bloccato

val(sO,T) = 0
=> NP(sH, T) = NV(sH, T) + 2 

• utilizziamo gli invarianti topologici

NP (sH, T) = NV (sO, T)
=> 0 <= NP(sO,T) - NV (sH,T) <= 1

• Cerchiamo un assurdo:

NV (sH, T) + 2 = NP (sH, T) = NV (sO, T) <= NV (sH,T) + 1

• Il risultato non e' ammissibile (2<1) quindi non e' possibile ottenere deadlock dalla soluzione presentata.

Uso di Semafori Privati

Semafori (binari/contatori) di proprieta' di uno o piu' processi. I proprietari sono gli unici a poter eseguire P sul suddetto semaforo, ma non ci sono restrizioni sull'uso di V.

Utilizzi

• Svegliare un determinato processo, per rendere la gestione di una coda di processi indipendente dall'implementazione del semaforo (kernel space). In questo modo posso stabilire una gerarchia di prorita' tra processi.

Vantaggi

Precisione nella gestione di pool di processi.

Svantaggi

Complessita' aggiunta all'implementazione: il programma deve mantenere piu' semafori (anche a livello di kernel: i semafori privati possono essere implementati al di fuori di una coda). Il caso piu' comune e' la necessita' di dover mantenere un semaforo per ogni processo in coda, invece che uno solo (e una coda).

Schemi di gestione

Schema 1

Contesto:

< struttura dati gestore >
semaphore mutex;
semaphore priv[n] = {0}; // array di semafori privati, ognuno dedicato a un processo (n processi)

Procedura di acquisizione

public int acquisisci (int p) {
	// simile ai semafori condizionali, anche qui dovremo testare l'ottenibilita' di una risorsa
	int j; // risorsa da allocare
	P (mutex);
	if ( ! Cp) { // Cp e' la condizione per il processo p
		< registrare sospensione del processo p >
		V (mutex);
		P (priv[p]); 
		< registro che il processo p non e' piu' sospeso >
	}
	< alloco risorsa j >
	V (mutex);
	return j;
}

Procedura di rilascio

public void rilascio (int j) {
	int p;
	P (mutex);
	< registro rilascio risorsa j >
	if ( < esiste almeno 1 processo sospeso > ) {
		< scelgo il processo p con massima priorita' >
		V (priv[p]);
	} else {
		V (mutex);
	}
}

Esempio: allocazione di pool di risorse

int avail = M;
bool libero[M] = {true};
bool sospeso[n] = {false};
int cnts = 0; // conta i sospesi
semaphore mutex;
semaphore priv[n] = {0}; // array di semafori privati, ognuno dedicato a un processo (n processi)

Procedura di acquisizione

public int acquisisci (int p) {
	int j; // risorsa da allocare
	P (mutex);
	if ( avail == 0) { 
		sospeso[p] = true;
		cnts++;
		V (mutex);
		P (priv[p]);
		sospeso[p] = false;
		cnts--;
	}
	avail--;
	while (libero[j]) j++;
	libero[i] = false;
	V (mutex);
	return j;
}

Procedura di rilascio

public void rilascio (int j) {
	int p;
	P (mutex);
	avail++;
	libero[j] = true;
	if ( cnts > 0 ) {
		p = maxpriority (sospeso); // ottengo il processo con priorita' massima
		V (priv[p]);
	} else {
		V (mutex);
	}
}

Schema 2

Siccome e' complesso dal punto di vista della programmazione strutturata (alto livello), e' stato proposto un secondo schema.

Procedura di acquisizione

public void acquisizione (int p) {
	P (mutex);
	if (Cp) {
		< alloca risorsa >
		V (priv[p]);
	} else {
		< registro sospensione processo p>
	}
	V (mutex);
	P (priv[p]); // a seconda del valore di Cp, questa P e' sospensiva (!Cp) o vanificata dalla V (Cp)
}

nota: la risorsa in questo caso e' garantita dal processo che rilascia, perche' se Cp non e' verificata, questa procedura non alloca nulla

Procedura di rilascio

public void rilascio (int j) {
	int p;
	P (mutex);
	< registro rilascio risorsa j >
	if ( < esiste almeno 1 processo sospeso > ) {
		< scelgo il processo p con massima priorita' >
		< alloco risorsa >
		< registro che p non e' sospeso >
		V (priv[p]);
	}
	V (mutex);
}

Pro e contro della soluzione 2

• Un problema della soluzione 2 e' che e' limitato a 1 dato libero per volta (se i processi consumatori hanno bisogno di piu' di un "dato" (risorsa), non ho modo di sapere quanti ne sto rilasciando), mentre la soluzione 1 implementata con un while risolve questo problema.

• Siccome il processo rilasciante si occupa anche di allocare le risorse, non si puo' effettuare il passaggio di parametri. Questo caso e' ovviato dall'utilizzo di un array condiviso allocazione che fornisce l'indice della risorsa che e' stata allocata.

Problema dell'accesso unico (senso unico alternato) - Readers & Writers

Precedenza agli scrittori

L'implementazione con precedenza agli scrittori permette di bloccare i readers se un writer e' nella SC, ma anche se un writer e' in attesa.

Soluzione bilanciata

Utilizzando dei semafori privati, e' possibile associare un semaforo privato a lettori e scrittori, ottenendo un accesso limitato degli scrittori alla SC, e quindi ottenendo una soluzione equilibrata.