[C/C++] Battaglia Navale in C

[P8257 WebMaster]

Bene .. (Y)

Scusa se insisto .. ma ..

i prototipi, sono obbligatori anche se il compilatore non ti da errore...

// Prototipi
void ClearScreen();
char ControllaRisultato(HANDLE, char, int, int);
void ControllaColpo(HANDLE);
void Scrivi(HANDLE);
void AggiornaCampo(void);
void PosizionaNavi(void);
void PrimaIstanza(HANDLE *, HANDLE);
void SecondaIstanza(HANDLE *, HANDLE);
// ------

Da inserire sotto i #define...

Bye

[P8257 WebMaster]

Suggerisco la creazione di un header separato, ora che vi sono prototipi, tipi strutturati, costanti ecc.

Bye

[LoryOne]

Piccolo programmino di esempio:

#include <windows.h>
#include <stdio.h>
#include <conio.h>

main(void){
   HANDLE sem;
   
   sem=OpenSemaphore(SEMAPHORE_ALL_ACCESS	,FALSE,"semaforo");
   if(sem==NULL){
      printf("Prima istanza del programma.");
      CreateSemaphore(NULL,0,1,"semaforo");
      sem=OpenSemaphore(SEMAPHORE_ALL_ACCESS	,FALSE,"semaforo");
      printf("\nResta in attesa della seconda istanza...");
      WaitForSingleObject(sem,INFINITE);
      printf("\nLa seconda istanza ha rilasciato il semaforo.\n"
             "Premi Invio per terminare.");
      CloseHandle(sem);
      getch();
   }   
   else
   {
      printf("Seconda istanza del programma\nPremi invio per " 
             "rilasciare il semaforo della prima istanza...");
      getch();
      ReleaseSemaphore(sem,1,NULL);
   }      
}

Ps:Non vi sono volontariamente controlli sulla possibilità o meno di creare i vari semafori ma è sempre buona norma farlo.

[Alhazred]

Gestire un solo accesso al semaforo va bene, ma è gestire continui accessi e rilasci che diventa difficoltoso e non lo è tanto lo schema mentale, quello l'ho ben chiaro, il fatto è che in time-sharing possono accadere cose alquanto bizzarre. Il mio problema è essere sicuro che in ogni momento in memoria condivisa ci sia il processo giusto. Nel caso della mia battaglia navale le due istanze dovranno scambiarsi dati e permettere o proibire all'altro di entrare in sezione critica senza un input dell'utente, ma gestirsi autonomamente.
Per ora sono orientato all'uso di due semafori, sem[0] per permettere o proibire alla prima istanza di accedere alla memoria condivisa e sem[1] per la seconda, la gestione sto pensando di farla in modo che sarà P1 ad occupare sem[0] quando gli serve, ma dovrà poi essere P2 a liberarlo quando avrà finito il suo lavoro in memoria condivisa e viceversa per sem[1].
Al momento mi sembra la soluzione più semplice, staremo a vedere con l'andare avanti del codice se è la pensata giusta o se dovrò rivedere tutto.

[Alhazred]

Ho definito HANDLE sem[2];
ora nel chimare PrimaIstanza o SecondaIstanza devo fare così?
PrimaIstanza(sem, mapping);
o così?
PrimaIstanza(sem[2], mapping);

vengono accettati entrambi i metodi, ma qual'è quello giusto in modo che ogni funzione veda entrambi i semafori?

Stessa cosa, va fatto così?
void SecondaIstanza(HANDLE *sem[2], HANDLE mapping) {
o così?
void SecondaIstanza(HANDLE *sem, HANDLE mapping) {

[P8257 WebMaster]

Alhazred
Gestire un solo accesso al semaforo va bene, ma è gestire continui accessi e rilasci che diventa difficoltoso e non lo è tanto lo schema mentale, quello l'ho ben chiaro, il fatto è che in time-sharing possono accadere cose alquanto bizzarre. Il mio problema è essere sicuro che in ogni momento in memoria condivisa ci sia il processo giusto. Nel caso della mia battaglia navale le due istanze dovranno scambiarsi dati e permettere o proibire all'altro di entrare in sezione critica senza un input dell'utente, ma gestirsi autonomamente.
Per ora sono orientato all'uso di due semafori, sem[0] per permettere o proibire alla prima istanza di accedere alla memoria condivisa e sem[1] per la seconda, la gestione sto pensando di farla in modo che sarà P1 ad occupare sem[0] quando gli serve, ma dovrà poi essere P2 a liberarlo quando avrà finito il suo lavoro in memoria condivisa e viceversa per sem[1].
Al momento mi sembra la soluzione più semplice, staremo a vedere con l'andare avanti del codice se è la pensata giusta o se dovrò rivedere tutto.

Gestire un accesso al semaforo o gestirne molti non è di per se molto diverso .. in memoria condivisa, personalmente ti suggerisco di trasportare l'id del processo che per ultimo ci ha acceduto oltre che il timestamp di questo ultimo accesso...

La soluzione proposta è valida a mio avviso.

Bye

[P8257 WebMaster]

Alhazred ha scritto:
Ho definito HANDLE sem[2];
ora nel chimare PrimaIstanza o SecondaIstanza devo fare così?
PrimaIstanza(sem, mapping);
o così?
PrimaIstanza(sem[2], mapping);

vengono accettati entrambi i metodi, ma qual'è quello giusto in modo che ogni funzione veda entrambi i semafori?

Stessa cosa, va fatto così?
void SecondaIstanza(HANDLE *sem[2], HANDLE mapping) {
o così?
void SecondaIstanza(HANDLE *sem, HANDLE mapping) {

Devi sempre referenziarti a Sem[2]

o puntare ad esso: *Sem[2]

Bye

[Alhazred]

Originariamente inviato da P8257 WebMaster

...
personalmente ti suggerisco di trasportare l'id del processo che per ultimo ci ha acceduto oltre che il timestamp di questo ultimo accesso...
...

Vediamo se ho capito cosa intendi propormi.
L'istanza che vuole accedere in memoria condivisa dovrebbe scriverci anche il suo id (lo faccio aggiungendo un campo al t_Mossa o come altro mi consiglieresti?) previo controllo che l'id al momento scritto è il suo oppure no, nel primo caso vorrebbe dire che il dato che attende non è ancora pronto e si rimette in attesa finchè non trova l'id dell'altra istanza. Il fatto del timestamp non lo capisco, non è sufficiente l'id?

[P8257 WebMaster]

Si, esattamente, come soluzione ti proponevo questa, registrare l'id del processo, aggiungendo un campo al tipo strutturato, il timestamp è un'ulteriore sicurezza, trovandolo ad ogni transazione sei sicuro che l'alro processo sia stato in grado di riempire adeguatamente la struttura che ti serve, inoltre facendo un "polling" del timestamp (diciamo che questo è un controllo aggiuntivo) puoi avere una sicurezza in più nel gestire le eventuali condizioni impreviste se l'altro processo non dovesse (per qualsiasi motivo) essere stato in grado di liberarti adeguatamente il semaforo...

Bye

[Alhazred]

Originariamente inviato da P8257 WebMaster
...
il timestamp è un'ulteriore sicurezza, trovandolo ad ogni transazione sei sicuro che l'alro processo sia stato in grado di riempire adeguatamente la struttura che ti serve
...

E come dovrei gestirlo per essere sicuro che l'altro processo abbia terminato il suo lavoro?
Stavo cercando nella guida MSDN, ma non sono riuscito a capire come usarlo.

[P8257 WebMaster]

Alhazred ha scritto:

E come dovrei gestirlo per essere sicuro che l'altro processo abbia terminato il suo lavoro?
Stavo cercando nella guida MSDN, ma non sono riuscito a capire come usarlo.

L'utilizzo del timestamp è un'ulteriore sicurezza nel senso che puoi "renderti conto" se il processo è stato in grado, non solo di capire che il semaforo era libero per poter leggere l'area di memoria condivisa, ma anche se sia stato poi in grado di scrivere su di essa dei dati "coerenti"... il semplice PID viene messo all'inizio della transazione dall'ultimo processo che ha acceduto alla memoria, un timestamp dovrebbe essere inserito dal processo alla fine delle operazioni sulla memoria condivisa per indicare che tutto si è svolto correttamente.

Questo, come detto, ti garantisce anche di poter fare dei controlli di "timeout" in modo che non ti sia poi tanto difficile gestire condizioni in cui cade uno dei due processi.. ripeto, questo controllo è opzionale, io lo consiglio, ma non è vitale al funzionamento dell'applicativo.

Bye

[Alhazred]

E se nel t_Mossa scrivessi prima i campi colonna e riga con i dati adeguati, e solo alla fine (subito prima di rilasciare il semaforo) aggiornassi il campo che conterrà l'id del processo che vi ha lavorato, ad esempio con una cosa così
p->proc_id = my_id;
mentre il processo attuale sta lavorando in memoria condivisa, l'altro troverebbe sempre il proprio id ed attenderebbe, giusto?
Anche in time sharing non dovrebbero esserci problemi, dato che quando il processo in attesa trova un altro id non ci saranno più istruzioni da eseguire da parte del processo concorrente.

[P8257 WebMaster]

Questa è una soluzione, tuttavia, dato che disponi di due potenziali dati di controllo .. il mio suggerimento era di mettere il PID all'inizio della transazione e il timestamp alla fine della transazione...

La tua soluzione è valida (il discorso del timestamp non è vitale) tuttavia potrebbe capitare che il secondo processo per qualsiasi motivo non riesca ad accedere e quindi a scrivere nella memoria condivisa, il primo processo troverebbe ancora il suo PID nella memoria e rimarrebbe bloccato...

Bye

[Alhazred]

Ok, però dovresti dirmi come dovrò usare il timestamp nel mio programma facendomi un esempio con del codice, come ho scritto in precedenza ho cercato nell'MSDN, ma non sono riuscito a capire come fare, tra l'altro per il timestamp non c'erano esempi.

[P8257 WebMaster]

Ok, scriverò un esempio più tardi

Bye