[C/C++] Battaglia Navale in C

[LoryOne]

Vediamo un po.
La prima istanza dovrebbe:
1) Creare il primo semaforo per se stessa.
2) Creare il secondo semaforo per la seconda istanza
3) Creare la memoria condivisa
4) Restare in attesa della seconda istanza che liberi il primo semaforo.

Quindi è la seconda istanza che deve rilasciarlo.
Lo fa ?
Non mi sembra.
Ricontrolla ed assicurati che possano essere lanciate solo 2 istanze dello stesso programma e che soprattutto la prima rimanga in attesa della seconda.

Ti assicuro che NON FUNZIONA per niente

[LoryOne]

Quanto vale sem[0] dopo il primo OpenSemaphore ?
Quanto vale la costante INVALID_HANDLE_VALUE ?
Sei sicuro della correttezza del flusso del codice che hai scritto ?

[Alhazred]

Originariamente inviato da LoryOne
Quanto vale sem[0] dopo il primo OpenSemaphore ?

Vale 0

Quanto vale la costante INVALID_HANDLE_VALUE ?

NULL

Sei sicuro della correttezza del flusso del codice che hai scritto ?

Fin'ora non mi ero ancora posto questo problema, sto ancora cercando di capire come gestire gli accessi in memoria condivisa.
Mi sembra però corretto fino a qui:
- parte la prima istanza
- crea ed apre i semafori 1 e 2
- crea ed apre la memoria condivisa
- rilascia il semaforo 2 quando ha fatto tutto questo
- se la seconda istanza parte prima che la prima abbia finito di creare i semafori e la memoria condivisa, resta in attesa perché ha come prima istruzione WaitForSingleObject(sem[1],INFINITE) e sem[1] all'atto della creazione vale 0

C'è qualcosa che non va?

[Alhazred]

Una cosa che non va è che il WaitForSingleObject(sem[1],INFINITE) devo metterlo dopo

sem[1] = OpenSemaphore(SEMAPHORE_ALL_ACCESS,FALSE,"sem2");
if(sem[1] == INVALID_HANDLE_VALUE)
      Errore_("Errore nell'apertura del semaforo 2");

altrimenti come fa ad attendere il semaforo se prima non lo apre? vero?
Però oltre questo mi sembra ok.

P.S. Dopo aver salvato le modifiche al file .c ho chiuso Visual C++, l'ho fatto ripartire, ho compilato e il warning non c'è più... mi sa che questo visual c++ non è un granché

[Alhazred]

Originariamente inviato da LoryOne
Vediamo un po.
La prima istanza dovrebbe:
1) Creare il primo semaforo per se stessa.
2) Creare il secondo semaforo per la seconda istanza
3) Creare la memoria condivisa
4) Restare in attesa della seconda istanza che liberi il primo semaforo.

Quindi è la seconda istanza che deve rilasciarlo.
Lo fa ?
Non mi sembra.

Non lo fa con il ReleaseSemaphore(sem[0],1,&dummy);?

Ricontrolla ed assicurati che possano essere lanciate solo 2 istanze dello stesso programma e che soprattutto la prima rimanga in attesa della seconda.

Che partiranno due sole istanze sarà sicuro quando avrò fatto un batch per il lancio del programma come suggeritomi da web. Per il momento per esserne sicuro starò attento a far partire 2 sole istanze manualmente.

Ti assicuro che NON FUNZIONA per niente

L'ho appena constatato, ho creato l'exe e l'ho fatto partire 2 volte, entrambe le volte va nel else del main, ovvero è come se fossero entrambe una seconda istanza. Pare che l'HANDLE per il sem[0] sia già valido prima che parta la prima istanza , perché questo?



E soprattutto, perché hai messo questa faccina ?

[LoryOne]

E soprattutto, perché hai messo questa faccina ?

, niente era uno sfogo.
Vorrei che tu imparassi bene da subito ma ti sei impelagato (termine ligure per esprimere incasinamento ) in un programma che necessita di una buona dose di esperienza e conoscenza del linguaggio che ancora non hai.

Ti ripeto:
Lascia perdere per un attimo quello che stai facendo e creati dei piccoli programmini ad hoc. Per esempio cerca di risolvere il fatto che la prima istanza non rimane in attesa del rilascio da parte della seconda.

Gestire i semafori è la cosa principale, devi aver chiaro il concetto.
Non ti serve un batch per evitare il lancio di sole due istanze, lo puoi fare direttamente nel tuo programma.

Ps:Non è una critica nei confronti di WebMaster, si può anche fare così, ci mancherebbe.

[Alhazred]

Originariamente inviato da LoryOne

...
Ti ripeto:
Lascia perdere per un attimo quello che stai facendo e creati dei piccoli programmini ad hoc. Per esempio cerca di risolvere il fatto che la prima istanza non rimane in attesa del rilascio da parte della seconda.
...

A dire il vero non esiste una prima istanza, come scritto sopra vengono riconosciute entrambe come seconda

[LoryOne]

Guarda qui:

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

HANDLE sem,sem1;

void Blocco(char *s){
   sem=OpenSemaphore(SEMAPHORE_ALL_ACCESS,FALSE,"semaforo");
   printf(s);
   printf("\nB L O C C A T O.");
   WaitForSingleObject(sem,INFINITE);
}   
      
int main(void){
   sem=OpenSemaphore(SEMAPHORE_ALL_ACCESS,FALSE,"semaforo");
   sem1=OpenSemaphore(SEMAPHORE_ALL_ACCESS,FALSE,"semaforo1");
   if(sem!=NULL && sem1!=NULL){
      printf("Sono ammesse solo 2 istanze del programma !");
      Sleep(1000);
      return 0;
   }   
   if(sem==NULL){
      printf("Prima istanza del programma.");
      CreateSemaphore(NULL,0,1,"semaforo");
      Blocco("\nResta in attesa della seconda istanza...");
      CloseHandle(sem1);
      printf("\nRilasciato");
   }   
   else{
      CreateSemaphore(NULL,0,1,"semaforo1");
      printf("Seconda istanza del programma\nPremi invio per " 
             "rilasciare il semaforo della prima istanza...");
      getch();
      ReleaseSemaphore(sem,1,NULL);
      return 0;
   }
   getch();
   CloseHandle(sem);
   return 0;
}

Cio che manca è l'impossibilità di chiudere il programma attraverso Alt-F4 o la pressione del mouse sul pulsante di chiusura della finestra o dall'elenco dei processi ma per ora non è fondamentale

Ps: Occhio all' INVALID_HANDLE_VALUE.
Io non ho messo i controlli per far prima (ed ho fatto male). tu ricordatene, mi raccomando !

INVALID_HANDLE_VALUE mi sta bene con CreateSemaphore e solo con questa funzione o con qualunque altra funzione Create...

[Alhazred]

Grazie al tuo esempio ho capito come fare in modo che partano solo 2 istanze e bloccare le eventuali in eccesso.
Inoltre adesso sostituendo l'INVALID_HANDLE_VALUE con NULL dopo gli open riesco ad entrare nella prima istanza.
Quale differenza c'è tra usare HANDLE sem[2]; (come sto facendo io) e usare HANDLE sem1, sem2; (come hai fatto tu)?

[Alhazred]

Ho una domanda, io ho messo questo codice perché l'ho visto scritto negli esempi, ho una mezza idea di quello che vuol dire, ma mi piacerebbe avere una spiegazione da parte di chi ne sa più di me

memset(&si, 0, sizeof(si));
memset(&pi, 0, sizeof(pi));
si.cb = sizeof(si);

[LoryOne]

memset è un'istruzione a basso livello solitamente utilizzata per azzerare velocemente il contenuto di un array o di una struttura.

Nel caso in esame, sizeof() esegue il calcolo del contenuto in bytes della struttura, tenendo conto della tipologia di ogni elemento che la costituisce.

[Alhazred]

Ci sono queste due cose che mi sono rimaste in sospeso e mi piacerebbe risolverle:

Per il controllo col timestamp:
- cosa deve aspettarsi di trovare l'istanza che vuole accedere alla memoria condivisa affinché sia sicura che l'altra abbia finito?
- il tempo di cosa ci sarà scritto in t.TimeStmp?

Per l'esempio di lory:
Quale differenza c'è tra usare HANDLE sem[2]; (come sto facendo io) e usare HANDLE sem1, sem2; (come hai fatto tu)?

[LoryOne]

Differenze non ce ne sono.
E' solo una questione di praticità che deriva da come hai progettato il tutto.
Nell'esempio che ho fatto mi sembrava superfluo utilizzare un array ma nella tua applicazione potrebbe aver senso.

[P8257 WebMaster]

Scusate, mi sono perso qualche post...

Nel controllo del timestamp devi aspettarti di ricevere dall'alra istanza un valore maggiore rispetto a quello che tu, come istanza attiva, avevi inserito la scorsa volta .. inoltre questo ti aiuta anche nel capire se l'altra istanza per qualsiasi motivo dovesse mancare di risponderti .. oppure per poter impostare un valore limite o un timeout ..

Il timestamp "grezzo" è poco "umano" come tipo di dati... se vuoi convertirlo in forma più leggibile ti basta guardare in time.h e troverai le funzioni per renderlo in giorni/mes/anni ecc. ecc. ma a mio avviso in questo caso non è necessario...

Bye

[Alhazred]

Ora è chiaro, grazie