problema dei 5 giocatori in C

[/\/\@®¢Ø]

Che compilatore usi ?

Un'altra cosa non capisco... come mai nel file hai incluso i pthread ? Poi non li usi mi sembra ...

[paplo]

veramente non lo neanche io perchè includiamo pthread.h. evidentemente è stata una modifica in corso d'opera.

il compilatore che uso in Windows è ... LCC-Win32.

il problema è che il cambiamento di stato del semaforo a destra e a sinistra non viene mai effettuato.
e allora come posso modificare???

Ciao,
Paplo

P.S: l'ultima modifica è questa ...

[MickMacello]

scusa ma...se la memoria non mi inganna(ho studiato sta roba anni fa e da allora non ho più avuto occasione di usarla):
tu ridefinisci il tipo int come tipo semaphore.
definisci le funzioni wait e signal che usano il tuo tipo semaphore cioè un semplice int...
Ma queste non sono funzioni atomiche. Devi usare quelle fornite dal sistema operativo che nel caso di linux sono contenute nelle librerie
wait.h, signal.h, unistd.h pthread.h ecc ecc (in win non saprei). Altrimenti la sincronizzazione tra processi non funzionerà mai.

[paplo]

x MickMacello

non capisco quello che vuoi dire!?

cmq. per il mio programma ho preso spunto dal programma dei 5 filosofi.
ecco le funzioni wait e signal che ho trovato ...

"
void wait(semaphore s)
{
int junk;
if(read(s[0], &junk, 1) <= 0) {
printf("ERROR: wait() fallita in creazione semaforo!\n");
exit(1);
}
}

void signal(semaphore s)
{
if(write(s[1], "x", 1) <=0){
printf("ERROR: write() fallita nella creazione semaforo!\n");
exit(1);
}
}
"

[cionci]

Così non va bene...è solo una simulazione della wait e della signal in caso di singolo processo...

La wait e la signal come già datto da MickMacello devono essere operazioni atomiche ovvero devono essere system call che lavorando a livello del kernel non possono essere interrotte dallo scheduler (o da altri programmi)...

Poi hai implementato il blocco sulla wait come una funzione chiamata up...quella funzione non esiste perchè è già implementata dalla system call wait...

In pratica wait è così :

void wait(semaphore *s)
{
  if ((*s)==0)
    mi_metto_in_attesa_passiva(); //ovvero lo schedule mi mette in
         //coda dei processi bloccati sul semaforo s
  --(*s);
}

Mentre la signal è in pratica così :

void signal(semaphore *s)
{
  ++(*s);
}

Dirai simili alle tue...ma devono essere atomiche...quindi anche le interruzioni esterne devono essere disabilitate...e questo avviene solo per le system call...

Ad esempio lo scheduler ti toglie il processore suito dopo averti svegliato da una wait...prima di eseguire --s...un altro processo fa una wait (s in questo momento è a 1 perchè un altro processo ha fatto una signal per svegliare il processo in attesa sul semaforo)...la wait non blocca per questo processo e s va a 0...
Ora che succede, quendo al primo processo viene riassegnato il processore esegue --s...quindi il semaforo si porta in uno stato inconsistente e probabilmente non più recuperabile !!!

Quindi sia wait che signal devono essere atomiche...quindi system call !!!

[cionci]

Inoltre le varie funzioni up, down, wait e signal che ha usato sono concettualmente sbagliate perchè dovrebbero lavorare con puntatori...altrimenti il valore di s che viene cambiato all'interno delle funzioni è solo valido all'interno delle stesse (fai un passaggio deid ati per valore)...

[/\/\@®¢Ø]

azz... io non me n'ero accorto... pensavo usate chiamate di sistema !

[paplo]

x Cionci

ho effettuato le modifiche che mi hai suggerito, però ...
mi da questi errori ...

"passing arg 1 of 'wait' from incompatible pointer type"
"passing arg 1 of 'signal' from incompatible pointer type"

presumo da ciò che devo creare una funzione che crei un semaforo, è vero?!
ma come devo fare!?!? AIUTO!!!

inoltre ho modificato il tuo wait affinchè se il semaforo S non è verde esca, ovvero salti il turno

void wait(semaphore *s)
{
if ((*s)==0)
exit(1); //ovvero lo schedule mi mette in
//coda dei processi bloccati sul semaforo s
--(*s);
}

è corretto???

Grazie mille,
Paplo

P.S. ecco il listato ...

[paplo]

il listato precendete è errato.

ve lo rimando corretto ...

[/\/\@®¢Ø]

Ma ti e' richiesto di crearti tu i semafori ?
Non ti sarebbe piu' semplice utilizzare le chiamate che ti forniscono le librerie ?

[cionci]

Originariamente inviato da paplo
[b]x Cionci

ho effettuato le modifiche che mi hai suggerito, però ...
mi da questi errori ...

Attenzione io non ti ho suggerito delle modifiche...quella che ti ho data è la possibile implementazione della wait e della signal a livello di kernel...
Tu non puoi implementare wait e signal...devi usare quelle fornite dal sistema operativo perchè devono essere atomiche !!!

[MickMacello]

paplo cazzarola non ci siamo. Devi usare le chiamate di sistema.
Togli le definizioni di wait e signal e includi le librerie di sistema che le implementano.
Nel tuo file sorgente non devono comparire queste righe:

void wait(semaphore s);
void signal(semaphore s);

void wait(semaphore s)
{
if ((*s)==0)
exit(1); //ovvero lo schedule mi mette in
//coda dei processi bloccati sul semaforo s
--(*s);
}


void signal(semaphore s)
{
++(*s);
}

[paplo]

vi ringrazio per la pazienza.

appena posso vi riferiro il risultato!

[paplo]

Originariamente inviato da /\/\@®¢Ø
[b]Ma ti e' richiesto di crearti tu i semafori ?
Non ti sarebbe piu' semplice utilizzare le chiamate che ti forniscono le librerie ?

ho controllato il testo dell'esercizio e c'è scritto ...
"Gli esercizi proposti nel seguito devono essere realizzati in C utilizzando, laddove è necessario, le chiamate di sistema e le funzioni di libreria del caso. "

così è molto più facile!

(un'altra volta sono stato costretto a creare un metodo Random in java perchè il professore non voleva che utilizassimo quello della libreria Math)

Ciao,
Paplo

[/\/\@®¢Ø]

Originariamente inviato da paplo
[b]
così è molto più facile!

Piu' che altro indispensabile...

[paplo]

Originariamente inviato da /\/\@®¢Ø
[b]

Piu' che altro indispensabile...

no ... ho trovato anche il problema dei 5 filosofi con le funzioni wait, signal e make_semaphore funzionanti.

[cionci]

Originariamente inviato da paplo
[b]no ... ho trovato anche il problema dei 5 filosofi con le funzioni wait, signal e make_semaphore funzionanti.

Funzionante male

Te l'ho detto...fidati... Ti può funzionare 10 volte, 100 volte, 1000 volte...ma sicuramente, per Murphy, ti andrà male proprio quando ti serve veramente !!!

Tutte le primitive di sincronizzazione DEVONO essere atomiche...o per lo emno devono appoggiarsi ad una primitiva di sincronizzazione atomica (ad esempio si possono implementare la wait e la signal con una mutex)...punto e basta...non ci sono alternative...
Altrimenti le puoi provare ad implementare come ti pare, ma saranno sempre errate...

[paplo]

Ciao,

ho provato ad utilizzare le funzioni atomiche, ma mi da cmq. errori ...

filosofi.c:19: warning: initialization makes pointer from integer without a cast
filosofi.c: In function `main':
filosofi.c:45: warning: assignment makes pointer from integer without a cast
filosofi.c: In function `put_cards':
filosofi.c:135: warning: passing arg 1 of `signal' makes integer from pointer without a cast
filosofi.c:135: too few arguments to function `signal'
filosofi.c:136: warning: passing arg 1 of `signal' makes integer from pointer without a cast
filosofi.c:136: too few arguments to function `signal'

putroppo non riesco a risolverli!

Ancora grazie per la disponibilità.

Ciao,
Paplo.

P.S.:il listato è ...

[paplo]

Ciao,

qualcuno mi suggerisce come inizializzare i semafori.

Grazie 1000,
Paplo.