Newsgroup: it.comp.os.linux.development
Titolo: processo in attesa su più semafori

Ciao a tutti,
ho un dubbio "amletico" che non riesco a sciogliere; spero che
possiate mettermi sulla retta via :-)
La situazione e' questa: un processo p con un set di semafori s1,
s2 ... sn.
Ad ogni semaforo corrisponde univocamente un segmento di memoria
condivisa m1, m2 ... mn.
I vari segmenti di memoria servono al processo per comunicare con
altrettanti processi n1, n2...nn; quello che vorrei ottenere, nelle
condizioni appena presentate, è un comportamento stile select()/poll
().
In tale processo potrei verificare, per ogni semaforo, se sia
possibile acquisirne il lock in maniera non bloccante; il problema è:
cosa gli faccio fare nel resto del tempo?! Supponiamo ad esempio che
tutti i semafori siano già lockati, alla fine di un ipotetico ciclo
while cosa faccio? Non so se mi sono spiegato...
Grazie per la collaborazione :)
lorENZ

 [...]
Ciao  Manlio Perillo

 Ciao  Manlio Perillo
Grazie.
Ciao,
loRENz

 while cosa faccio? Non so se mi sono spiegato...
Io proverei a creare un super-semaforo per segnalare cambiamenti nello stato dei 
semafori privati. Quando p trova che tutti i semafori sono presi, si mette in 
attesa sul super-semaforo. I processi n*, dopo aver cambiato lo stato del loro 
semaforo s* cambiano lo stato anche del super-semaforo. Ovviamente il 
trattamento del super-semaforo deve poter gestire cambiamenti concorrenti...
In alternativa potresti creare un mailbox per implementare la funzione del 
super-semaforo.
Un metodo piu` rude sarebbe di far fare ai processi n* un kill per il processo 
centrale. Il processo centrale dichiara un signal handler prima di fare lo 
sleep. Qui il problema e` che cosa succede se il segnale arriva altrove, quando 
il processo non e` in sleep ma e` invece su una system call.
Ciao,
-- 
        Roberto Divia`              Love at first sight is one of the greatest
Dep:PH Bat:53 Mailbox:C02110      labour-saving devices the world has ever seen
Route de Meyrin 385               ---------------------------------------------
Case Postale                                Phone:  
+41-22-767-4994
CH-1211 Geneve 23 CERN                      Fax:    
+41-22-767-9585
Switzerland                                 E-Mail: 
Robert...@cern.ch

 il processo non e` in sleep ma e` invece su una system call.
A questa c'avevo pensato...ma non mi piace un granchè. Diciamo che la
lascio come ultima ratio
Grazie mille per le dritte.
Saluti,
lorENZ

 verificato i semafori?
sleep fa lo stesso.
Solo che sospendi il processo per qualche tempo in più.
Ciao  Manlio

 diventerebbero ridondanti; no?
Si, potresti usare il mailbox al posto dei semafori. Basta che il processo 
figlio mandi un identificatore al padre su quale blocco di memoria usare.
Potresti anche provare un approccio ibrido. I figli usano la memoria condivisa 
anche per indicare che hanno bisogno del padre (per esempio con una coppia 
atomica di identificatori richiesta-risposta) e in piu` mandano il messaggio al 
mailbox o al semaforo globale. Il padre prima interroga le memorie condivise e, 
se non trova niente, si mette in attesa sul mailbox-semaforo. Cosi` puoi 
assicurare una risposta veloce quando hai richieste in attesa piu` una risposta 
entro un ritardo ragionevole quando non hai richieste in attesa. In questo caso 
il semaforo globale diventa l'opzione piu` efficace.


 dal super-semaforo. Più o meno dovrebbe andare no?
Io semplificherei il tutto e userei un semaforo binario per il super-semaforo. 
Tanto non ti serve sapere quanti figli hanno bisogno del padre ma piuttosto che 
hai degli figli in attesa, quanti e quali non ti serve saperlo (a questo 
livello, intendo).
Occhio agli accessi concorrenti. I figli devono (1) accendere il segnale 
individuale e (2) accendere il semaforo globale, il padre deve (1) pulire il 
semaforo globale e (2) verificare lo stato dei figli. L'ordine 1-2 e` importante ;-)
