[C]Sincronizzazione tra processi

[domenico88]

Salve
Sto studiando sistemi operativi e sono un po' fermo su questo argomento da alcuni giorni -IPC(inter Comunication Process)-
In sostanza non riesco a capire come viene risolto il problema del deadlock tra i processi produttore e consumatore attraverso i semafori

Il codice del produttore e del consumatore con le chiamate sleep() e wakeup() mette in evidenza la problematica dello stallo tra i processi quando viene schedulato il consumatore un istante prima che esegua la chiamata sleep(), nel caso in cui il buffer sia vuoto con count uguale a zero.
In questo caso il produttore prende l esecuzione ed inserisce un elemento nel buffer, controlla se il buffer era vuoto e chiama wakeup() verso il consumatore

A questo punto se viene ripristanato il consumatore dallo scheduler per l esecuzione, il consumatore ancora non ha chiamto sleep ed il segnale di wakeup() viene perso. Riprendendo l esecuzione chiamerà sleep e andrà in wait
Il produttore eseguendo il codice riempirà il buffer ed eseguirà sleep a sua volta ed entrambi saranno in stato di sleep.

#define  N 100
 
   int count = 0;

 void produttore(){

   int item;

while(TRUE){

   item = produceItem();
   
   if(count == N) //se il buffer è pieno va a sleep
     sleep();
   
   insertItem(item);
   count = count +1;
   
   if(count ==1)   //Se il buffer era vuoto risveglia il consumatore
     wakeup(consumatore);
   }
}

 void consumatore(){

   int item;

 while(TRUE){
   
   if(count == 0) //se il buffer è vuoto sleep
     sleep();
   
   item =removeItem();
   count = count -1;
   
   if(count == N -1) //Se il buffer era pieno risveglia il produttore
     wakeup(produttore);

   }
}

Il testo dice che attraverso i semafori viene risolto il problema della perdita dei wakeUp

Un semaforo che vale zero che sta ad indicare che non sono stati salvati dei wakeup o un numero maggiore di zero se uno o più wakeup sono in attesa(qua non ho per niente capito cosa vuole dire)
Le operazioni sui semafori sono down e up(analoghi a sleep e wakeup)
-down verifica se il valore è maggiore di zero, se è così decrementa il valore e continua, se è zero è sospeso
-up aumenta il valore del semaforo indirizzato, se uno o più processi stavano dormendo su quel semaforo, uno di loro è schedulato per completare il suo down

Qua non riesco proprio a capire, e il codice con i semafori altrettanto
Cioè non riesco a capire come i semafori riescono ad evitare le corse critiche e risolvere il problema della perdita di wakeup...

Nel codice dichiara tre semafori, uno mutex per l accesso alla regione critica ,uno empty impostato a N e uno Full impostato a zero
Spero che qualcuno mi possa dare una mano
Vi ringrazio comunque per la gentile attenzione

[domenico88]

Grazie mille Antonio

In effetti la questione che non riesco a capire è proprio questa

Originariamente inviato da Antonio23

un semaforo binario rinforza il concetto di sincronizzazione: un thread che fa la wait su un semaforo viene sbloccato da un altro thread che fa una release sullo stesso semaforo.

Per sincronizzazione viene inteso il fatto che solo un processo per volta può eseguire la sua sezione critica andando a lavorare su variabili o risorse condivise da altri processi..(Giusto?)

Quindi un processo o un thread che fa una wait( chiamata down() o sleep() analogamente ) su un semaforo viene sbloccato da un altro thread che farà un up() sullo stesso semaforo(up sarebbe analogo a wakeup).. umm
forse ci sto arrivando...

[pabloski]

Originariamente inviato da domenico88

Il codice del produttore e del consumatore con le chiamate sleep() e wakeup() mette in evidenza la problematica dello stallo tra i processi quando viene schedulato il consumatore un istante prima che esegua la chiamata sleep(), nel caso in cui il buffer sia vuoto con count uguale a zero.
In questo caso il produttore prende l esecuzione ed inserisce un elemento nel buffer, controlla se il buffer era vuoto e chiama wakeup() verso il consumatore

Esattamente. Il problema e' che tra la valutazione della condizione e la decisione di mettersi in sleep/inviare il segnale all'altra entita', puo' accadere che il processo in esecuzione ( consumatore o produttore ) venga sospeso e il controllo della cpu passi all'altro.

Originariamente inviato da domenico88

In sostanza non riesco a capire come viene risolto il problema del deadlock tra i processi produttore e consumatore attraverso i semafori

Se guardi com'e' fatto un semaforo sotto il cofano, troverai questo

wait()
	if sem.val > 0 then
		sem.val = sem.val - 1
	else
		blocca processo
end

signal()
	if processi bloccati su sem then
		attiva i processi
	else
		sem.val = sem.val + 1
end

nota che grosso modo e' simile al codice che hai postato, con una grandissima differenza pero'....i blocchi signal e wait non sono preemptibile, cioe' non e' possibile che l'esecuzione venga sospesa nel bel mezzo di uno di quei blocchi

e questo e' garantito dalla cpu, tramite apposite istruzioni e relativi meccanismi

[domenico88]

Grazie mille forse sono riuscito a capire come funziona il codice con i semafori anche se ho ancora dei dubbi su alcune cose.. forse è un argomento particolare che proprio non mi entra bene...