[C/C++] Battaglia Navale in C

[Alhazred]

Dato che devo distinguere solo 2 casi mi sa che uso
if(istanza == 1)
{
codice prima istanza
}
else
{
codice seconda istanza
}

[P8257 WebMaster]

Mi sembra che scorra bene il codice (Y)...

I blocchi strutturati in C/C++ (e altri linguaggi derivati) hanno la seguente sintassi:

switch(variabile)
{
   case <caso>: <istruzioni>
                break;

   ...
   default: istruzioni
            break;

}

Attenzione che in C, a differenza di altri linguaggi, la variabile deve essere intera oppure direttamente "castabile" in int, come un char ad esempio.

Usa questo al posto di if.. else if .. è più corretto...

Bye

[Alhazred]

Ho aggiunto lo switch e alcune istruzioni, all'interno dello switch ancora non sono tutte.
Per decidere chi inizia ho pensato di generare un numero casuale tra 1 e 2, confrontarlo con instanza e inizierà chi otterrà TRUE dal confronto, è giusta l'istruzione primo = 1 + (rand()%2) per generare il numero casuale?

int main(int argc, char*argv[]) {
	HANDLE hOut;
	int i = 0, j = 0, primo;
	int istanza = 0;
	long dummy;

	HANDLE mapping, sem;
	STARTUPINFO si;
	PROCESS_INFORMATION pi;

	//Inizializzazione della griglia di gioco
	for(i=1; i<11; i++)
		for(j=1; j<11; j++)
			cArray[i][j] = ' ';	

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

	mapping = CreateFileMapping(INVALID_HANDLE_VALUE,
						NULL,PAGE_READWRITE,
						0,
						0,
						"shared_mem");

	if(mapping == INVALID_HANDLE_VALUE) //se è vera, questa è la prima istanza del programma
		istanza = 1;
	else istanza = 2;
	
	switch(istanza)
	{
		case 1:
			//Creazione memoria condivisa
			mapping = CreateFileMapping(INVALID_HANDLE_VALUE,
						NULL,
						PAGE_READWRITE,
						0,
						0,
						"shared_mem");

			if(mapping == INVALID_HANDLE_VALUE)
				Errore_("Errore nella creazione della memoria condivisa");

			//Creazione semaforo
			sem = CreateSemaphore(NULL,0,1,"semaforo");
			if(sem == INVALID_HANDLE_VALUE)
				Errore_("Errore nella creazione del semaforo");

			sem = OpenSemaphore(SEMAPHORE_ALL_ACCESS,FALSE,"semaforo");
			if(sem == INVALID_HANDLE_VALUE)
				Errore_("Errore nell'apertura del semaforo");
	
			WaitForSingleObject(sem,INFINITE);//attende il rilascio del semaforo da parte della
							//seconda istanza per sapere quando è attiva
			ReleaseSemaphore(sem,1,&dummy);//ora sa che la seconda istanza è attiva
			primo = 1 + (rand()%2); //genera un numero casuale per decidere chi inizia

			break;

		case 2:
			sem = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, "semaforo");
			if(sem == INVALID_HANDLE_VALUE)
				Errore_("Errore nell'apertura del semaforo");

			ReleaseSemaphore(sem,1,&dummy);//consente l'accesso al semaforo da parte
							//della prima istanza in modo che sappia
						         //che la seconda è attiva
			break;
	}

	hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    
	posizione.X = 0;
    posizione.Y = 24;
	SetConsoleCursorPosition(hOut,posizione);
}

[P8257 WebMaster]

Si, l'istruzione è giusta per generare il numero casuale.

Bye

[P8257 WebMaster]

C'é una certa ridondanza nel codice ... il caso 1 può benissimo essere gestito a partire dall'handle della prima chiamata a CreateFileMapping... poiché già da lì capisci se quella è la prima o la seconda istanza...

Questo mi fa venire in mente un aneddoto in cui il mio professore d'informatica si sbellicò dalle risate perché mi chiese di fare un programma per controllare se un numero fosse pari o dispari .. ed io controllavo prima che fosse pari .. e poi che fosse dispari ....

Bye

[Alhazred]

Dici di fare così?

int main(int argc, char*argv[]) {
	HANDLE hOut;
	BOOL inizia = FALSE;
	int i = 0, j = 0, primo;
	int istanza = 0;
	long dummy;

	HANDLE mapping, sem;
	STARTUPINFO si;
	PROCESS_INFORMATION pi;

	//Inizializzazione della griglia di gioco
	for(i=1; i<11; i++)
		for(j=1; j<11; j++)
			cArray[i][j] = ' ';	

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

	sem = OpenSemaphore(SEMAPHORE_ALL_ACCESS,FALSE,"semaforo");
	if(sem == INVALID_HANDLE_VALUE) //se è vera, questa è la prima istanza del programma
						{
            //Creazione memoria condivisa

		mapping = CreateFileMapping(INVALID_HANDLE_VALUE,
						NULL,
						PAGE_READWRITE,
						0,
						0,
						"shared_mem");

		if(mapping == INVALID_HANDLE_VALUE)
			Errore_("Errore nella creazione della memoria condivisa");

		//Creazione semaforo
		sem = CreateSemaphore(NULL,0,1,"semaforo");
		if(sem == INVALID_HANDLE_VALUE)
			Errore_("Errore nella creazione del semaforo");

		sem = OpenSemaphore(SEMAPHORE_ALL_ACCESS,FALSE,"semaforo");
		if(sem == INVALID_HANDLE_VALUE)
			Errore_("Errore nell'apertura del semaforo");
	
		WaitForSingleObject(sem,INFINITE);//attende il rilascio del semaforo da parte della
						//seconda istanza per sapere quando è attiva
		primo = 1 + (rand()%2); //genera un numero casuale per decidere chi inizia

		p->riga = primo;
			
		if(primo == istanza)
			inizia = TRUE;
			
		ReleaseSemaphore(sem,1,&dummy);//ora sa che la seconda istanza è attiva
		
	}
	else
	{
		sem = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, "semaforo");
		if(sem == INVALID_HANDLE_VALUE)
			Errore_("Errore nell'apertura del semaforo");

		ReleaseSemaphore(sem,1,&dummy);//consente l'accesso al semaforo da parte
						//della prima istanza in modo che sappia
						//che la seconda è attiva
		WaitForSingleObject(sem,INFINITE);

		primo = p->riga;

		if(primo == istanza)
			inizia = TRUE;
		ReleaseSemaphore(sem,1,&dummy);
	}

	hOut = GetStdHandle(STD_OUTPUT_HANDLE);
    
	posizione.X = 0;
    posizione.Y = 24;
	SetConsoleCursorPosition(hOut,posizione);
}

Ho anche aggiunto dell'altro codice, così dovrei aver finito di gestire la parte iniziale che crea la memoria condivisa, il semaforo e decide chi comincia.
Come sto andando?

[P8257 WebMaster]

Si, proprio così ..

Bene (imho) (Y)

Bye

[Alhazred]

Mi sto rendendo conto di una cosa, sto assumendo che il pc eseguirà le istruzioni così come le penso io, però c'è da considerare l'effetto time sharing, questo potrebbe sballare la situazione dell'accesso alla sezione critica. Qualche suggerimento su come fare?

[P8257 WebMaster]

IMHO un counter... o una struttura di controllo

Bye

[Alhazred]

Originariamente inviato da P8257 WebMaster
IMHO un counter... o una struttura di controllo

Bye

Mi spiegheresti meglio?
Come dovrei usare tale counter?
Come dovrei impostare la struttura di controllo?

[P8257 WebMaster]

La struttura di controllo da "ficcare" nella memoria condivisa deve tenere conto di alcuni parametri scritti e letti da entrambi i processi:

1 - Id del processo creatore
2 - Id del processo che per ultimo ha acceduto all'area condivisa
3 - timestamp dell'ultimo accesso
4 - parametri da passare da un processo all'altro

Questi sono i requisiti minimi, per essere sicuro che:

A - il processo creatore dell'area sia la prima istanza dell'applicazione
B - L'ultima scrittura sia stata fatta da un'altra istanza dello stesso processo e non da un processo diverso o estraneo
C - Che l'ultima scrittura sia identificabile attraverso un certo intervallo "temporale"

... trasporta questi dati da un processo all'altro, ti permetteranno di gestire meglio il tutto.

Bye

[Alhazred]

E se usassi una cosa di questo tipo?

HANDLE sem[2];
...
tutto il codice per aprire ed inizializzare in modo appropriato i due semafori
...

e usare sem[0] per far accedere P1 alla memoria condivisa e sem[1] per farvi accedere P2

[P8257 WebMaster]

Alhazred ha scritto:
E se usassi una cosa di questo tipo?

HANDLE sem[2];
...
tutto il codice per aprire ed inizializzare in modo appropriato i due semafori
...

e usare sem[0] per far accedere P1 alla memoria condivisa e sem[1] per farvi accedere P2

L'idea è buona .. ma in certi aspetti potrebbe risultarti difficile da gestire...

Bye

[Alhazred]

Il programma ora dovrebbe fare quanto segue, ma non riesco a proprio a pansare al codice adatto a gestire gli accessi in memoria condivisa.
Lo schema da seguire è quello postato qualche pagina indietro, ovvero

1 - Dopo aver posizionato le navi entrambi i processi si mettono in attesa
    (semaforo occupato)
2 - si sorteggia chi inizia
3 - il processo non sorteggiato (P2) resta in attesa che in memoria
    condivisa ci sia la coordinata fornita dall'altro processo (P1)
4 - si comunica a P1 di iniziare (semaforo libero per P1)
5 - P1 chiede al proprio utente di inserire una coordinata
6 - P1 accetta la mossa controllando che sia valida e la scrive
    in memoria condivisa (P1 rilascia il semaforo in favore di P2)
7 - si comunica a P2 che il dato che cerca è pronto (semaforo libero per P2)
8 - P2 cerca una corrispondenza tra le coordinate inserite dal suo utente
    all'inizio, se tale corrispondenza esiste o no
9 - nel caso esiste, P2, decrementa il numero di navi non colpite e controlla
    quante ne restano
10 - se le navi rimanenti sono + di 0 comuinca in memoria condivisa che una nave
     è stata colpita rilasciando poi il semaforo in favore di P1
11 - se le navi rimanenti sono 0 comunica in memoria condivisa che ha perso
     rilasciando poi il semaforo in favore di P1
12 - P1 occupa il semaforo, elabora il risultato fornito da P2 e fa apparire un
     simbolo corrispondente all'esito della mossa sulla griglia del proprio
     utente oppure comunica la vittoria, rilascia il semaforo e attende
     la mossa di P2
13 - si ripetono i passi da 4 a 12 invertendo P1 con P2 e così via finché
     qualcuno ha vinto.

Le funzioni che fanno il lavoro descritto già ci sono, Scrivi() e Controlla(), il problema è essere sicuri che vengano eseguite nell'ordine giusto.

[Alhazred]

Ecco l'intero codice con i controlli di Scrivi() completi così come quelli di ControllaColopo() (spero) e l'aggiunta di una funzione che controlla l'esito di un colpo.