problema dei 5 giocatori in C

[paplo]

Ciao,

sto cercando di risolvere il seguente problema in C ...

"
Si realizzi mediante thread e sincronizzazione con semafori un processo che
simula 5 giocatori, seduti ad un tavolo circolare, che giocano a carte. Si
supponga a questo proposito di avere un mazzo di 40 carte, la cui estrazione
sia ottenuta per mezzo di un generatore pseudocasuale. Il gioco consiste
nell'assegnare, durante la prima mano, una carta a testa per giocatore da
porre alla sua destra. Un giocatore per poter giocare la sua mano deve poter
disporre di entrambe le carte, alla sua destra e alla sua sinistra
(quest'ultima assegnata al giocatore sinistro). Se sono disponibili le
preleva (per cui non possono essere utilizzate contemporaneamente dai
giocatori che gli stanno accanto) e, quindi, estraendo una carta dal mazzo
ne fa la somma (modulo 40) con le due carte prelevate ai suoi lati e le
ripone sul tavolo. Si simuli la partita per un certo numero di mani.
"

Il problema è molto simile a quello dei 5 filosofi, e su questo problema mi sono basato per trovare una soluzione, ma il programma non funziona ancora.

per questo lancio un SOS.
quale l'errore nel listato e l'eventuale soluzione ???
(il listato è in allegato)

Vi ringrazio per qualsiasi aiuto mi vogliate dare!

Ciao e grazie,
Paplo

[MickMacello]

non mi è ben chiaro il funzionamento del gioco.

[paplo]

cosa non capisci???

cosa devono fare i giocatori !?

spero che le righe seguenti ti possano far capire ...
(se ti può consolare, neanche io capisco il prof! )

"Questo esempio è una variante del problema dei cinque filosofi che, nel caso in esame, può ribattezzarsi nel problema dei cinque giocatori. Ogni giocatore,
se lo può fare, prende la propria carta e quella del vicino e le sostituisce con le loro somme successive modulo Cards essendo Cards + 1 il numero di carte del
mazzo."

Ciao,
Paplo

[a2000]

solo in C eh ?

[MickMacello]

Esistono librerie fortran per scrivere programmi multiprocesso ?

[/\/\@®¢Ø]

L'errore che commetti e' che quando vuoi far prendere le carte al giocatore usi due wait.

In pratica il giocatore prende la prima carta , se non c'e' aspetta, quando ce l'ha prende la seconda , e se non c'e' aspetta.

Di conseguenza per come l'hai impostato tu, ogni giocatore prima prende la carta alla sua destra ( ad esempio ), e poi aspetta in eterno che il suo vicino molli la propria.

Cosa che non accadra' mai

Quindi devi prima limitarti a controllare se la carta e' disponibile , se non lo e' rinunciare, e se invece non lo e' prenderla. Stessa cosa per la seconda. Se riesce a pescarle tutte e due gioca, altrimenti molla l'eventuale carta presa e finisce il proprio turno

Non so il nome della funzione da invocare al posto di wait.
Con i pthread_mutex se non sbaglio c'e' la funzione pthread_mutex_trylock(), nel tuo caso probabilmente si chiamera' trywait()

[paplo]

ho indagato per trovare l'errore, e l'ho trovato ....

in pratica sbagliavo quando richiamavo LEFT e RIGHT.
la giusta sintassi infatti è LEFT(i) e RIGHT(i).

dopo aver risolto questo problema, ne abbiamo incontrati altri che abbiamo superato.

adesso il programma restituisce qualcosa, ma qualcosa che non è esatta.
infatti tutti i giocatori accedono al mazzo contemporaneamente e pescano la stessa carta.

penso che il problema sia il wait come dice /\/\@®¢Ø .

allego il listato modificato.
vi ringrazio se potete darci un'occhiata.

Ciao,
Paplo.

[paplo]

bè ... l'ho allego qui ....

[paplo]

Originariamente inviato da a2000
[b]solo in C eh ?

sì!!!!!

non in FCA o FORTRAN !!!

[paplo]

Originariamente inviato da /\/\@®¢Ø
[b]Quindi devi prima limitarti a controllare se la carta e' disponibile , se non lo e' rinunciare, e se invece non lo e' prenderla. Stessa cosa per la seconda. Se riesce a pescarle tutte e due gioca, altrimenti molla l'eventuale carta presa e finisce il proprio turno

ma se i giocatori a sinistra e a destra fossero più veloci del giocatore al centro, il giocatore al centro non giocherebbe mai?!

Ciao e grazie,
Paplo

[/\/\@®¢Ø]

Ah, devono giocare per forza in un dato turno ?
Io pensavo che semplicemente chi puo' gioca e gli altri "s'attaccano"
Un modo naïve può essere quello , con l'algoritmo che ti ho delineato, di continuare a provare fino a che uno non riesce a giocare:
Aspetta la prima carta ( qui va bene il wait ), e cerca poi di prendere la seconda ( trywait o quel che è ): se ce la fa gioca, altrimenti rimetti giu' la carta e riprova. Il discorso fondamentale è che o prendi su entrambi le carte o le lasci giu', non puoi tenerti in mano una sola carta e aspettare che si liberi la seconda, altrimenti non si riesce a giocare.
( sempre che abbia capito correttamente il gioco of course )

[/\/\@®¢Ø]

tanto per capirsi pensavo ad una cosa simile :


void take_cards(int i) /* i= numero del filosofo, 0.. N-1 */
{
bool ok=false;
while( ! ok )
{
if (i == 0){
wait(s[RIGHT(i)]);
printf("Il giocatore %d prende la carta destra.\n", i+1);
if ( trywait(s[LEFT(i)]) ) // controlla come funziona questo !
{
ok = true;
sleep(1); // simula una presa lenta per simulare il deadlock
}
else // la seconda carta non e' disponibile, rimettiamo a posto la prima e riproviamo
signal( s[RIGHT(i)]);

}
...


in questo caso ho ipotizzato che la trywait ritorni TRUE ( non zero ) se riesce a bloccare il semaforo, FALSE altrimenti, dovresti controllare in realta' se e' cosi' o meno

[paplo]

/\/\@®¢Ø, avevi capito bene prima.

questa mattina ho chiesto al prof. e in sostanza che prima arriva meglio alloggia.
cmq. è più semplice far saltare il turno ad un giocatore che tenere conto dellle mani, non è vero!?

cmq. nella prima soluzione che hai proposto sono superflui i semafori.
ovvero è neccessario soltanto un array che memorizzi gli stati delle carte.
ho inteso bene?

Ciao e grazie,
Paplo

[/\/\@®¢Ø]

No ! I semafori ti servono proprio per accedere a quell'array in modo sincronizzato.

Mi spiego meglio:
Supponiamo che nell'array tu memorizzi 1 se la carta e' disponibile 0 altrimenti. Se memorizzi solo lo stato puo' succedere che due giocatori cerchino di prendere la stessa carta contemporaneamente o quasi, ad esempio A vede 1 e decide di prendere la carta, in quel momento la cpu passa a B che vede anche lui 1, si ritorna ad A che imposta il valore a 0 ( si prende la carta ) , e la cpu ritorna a B che fa lo stesso. Due persone con la stessa carta in mano.
Se invece del contatore usi il semaforo ( che non e' altro che un contatore sincronizzato ) dopo che A "blocca" il semaforo ( la puoi considerare come una operazione "indivisibile" ) B si vede subito 0 e quindi non puo' prendersi la carta.
Spero di non averti confuso le idee ancora di piu'

[a2000]

Originariamente inviato da paplo
[b]

sì!!!!!

non in FCA o FORTRAN !!!

e in Excel ?

[a2000]

Originariamente inviato da MickMacello
[b]Esistono librerie fortran per scrivere programmi multiprocesso ?

disponibili fin dai primi anni '60:
vedi algoritmi per la risoluzione dell'equazione di Navier-Stokes ai volumi finiti e variabili segregate.


ragazzi col fortran non si gioca, si fa la guerra ! (e la pace)


P.S.
mi sembra poi che, in generale, chi si occupa dei linguaggi di programmazione solo per gestire funzioni di macchina e flussi di dati abbia un certo ritardo culturale, diciamo un delay puro, come le palle dei cani

[MickMacello]

Originariamente inviato da a2000
[b]
P.S.
mi sembra poi che, in generale, chi si occupa dei linguaggi di programmazione solo per gestire funzioni di macchina e flussi di dati abbia un certo ritardo culturale, diciamo un delay puro, come le palle dei cani

Che ci vuoi fare, non ci sono più gli insegnanti di una volta...

[paplo]

Ciao,

vi chiedo un piccolo favore ancora ....

mi potreste inviare o postare questi file ...

pthread.h
semaphore.h
stdio.h
stdlib.h
time.h

putroppo non ho installato Linux ed il compilatore per Windows non li ha a disposizione.

la mia email è [email protected]


Vi ringrazio molto!

Ciao,
Paplo

[/\/\@®¢Ø]

pthread e' specifico di una libreria e non basta copiarle l'header la devi avere tutta.

Ho trovato un port dei pthread qui , dovresti pure trovare le dll gia' precompilate. "semaphore.h" forse e' un header di linux , pero' nei pthreads ci sono pure i semafori , si tratta solo di cambiare i nomi delle funzioni.

Potresti in alternativa usare le api di win32 , pero' temo che per il tuo progetto non vada bene.


stdlib.h e stdio.h invece dovrebbero essere standard , strano che tu non le abbia.

Se usi un compilatore C++ invece che prova a includere cstdlib e cstdio.

Stessa cosa per time.h. Non so se e' standard, comunque ctime del C++ lo e'.

[paplo]

Originariamente inviato da /\/\@®¢Ø
[b]stdlib.h e stdio.h invece dovrebbero essere standard , strano che tu non le abbia.

credo anche io che siano standard, ma non ho avuto modo di sapere se vi sono perchè mi restituisce solo un errore per volta il compilatore.

Ciao e grazie,
Paplo