[C] progetto porto

[lucadue]

Ho bisogno di due dritte per iniziare il progetto e su come risolverso... non richiedo la soluzione ma se mi aiutate ad organizzare su come vanno gestite le cose... :muro: :muro: :help:

Scopo del progetto è gestire il transito delle imbarcazioni in un porto seguendo le
specifiche qui riportate.
All'inizio dell'esecuzione il porto è vuoto. Vengono generate tramite un processo
un certo numero di imbarcazioni che cercano di entrare nel porto. NB: il numero
di moli è limitato quindi al più 10 imbarcazioni possono soggiornare
contemporaneamente nel porto. Dopo un po' di tempo trascorso a riva (variabile
da imbarcazione a imbarcazione), ogni imbarcazione prende il largo liberando il
molo che occupava.
L'accesso al porto avviene tramite un canale gestito come senso unico alternato.
Ad intervalli regolari vengono fatte entrare alcune imbarcazioni nel porto e poi
fatte uscire alcune imbarcazioni. La durata dei periodi di ingresso ed uscita è
identica. Quindi quando è il turno degli ingressi, le navi ferme al largo iniziano a
entrare, e continuano a farlo per un certo tempo prefissato (a patto che ci siano
moli liberi). Allo scadere del tempo, l'ingresso viene bloccato e si consente alle
navi pronte a partire di uscire, sempre per un tempo prefissato.
Ogni imbarcazione attraccata, avvisa la capitaneria di porto inviando un
messaggio su di una coda (unica per tutte le imbarcazioni e per la capitaneria),
indicante il nome della nave, il carico ed eventuali altre informazioni ritenute
utili. La capitaneria di porto registra tali messaggi in un'area di memoria
condivisa (il registro della capitaneira).
A campione, la capitaneria di porto effettua dei controlli su di alcune
imbarcazioni. A tal fine il processo si forka generando un controllore. Controllore
e nave si scambiano alcune informazioni secondo il protocollo descritto nel
seguito. Il controllore riporta nel registro tutti i passi.
Messaggio 1: da capitaneria a nave: CHECK_START
Messaggio 2: da nave a capitaneira: materiale trasportato + quantità
Messaggio 3: da capitaneira a nave: OK oppure MULTA
La terminazione di tutti i processi figli va intercettata dal corrispodente genitore,
che in tale occorrenza esegue la wait/waitpid.

datemi una mano grazie mille

Luca :cool:

[banryu79]

datemi una mano grazie mille

Fai delle domande specifiche e/o posta una tua almeno parziale soluzione/pseudo-implementazione.

Questo perchè in questo Forum è vietato postare soluzioni intere di esercizi, e tantomeno chiedere soluzioni intere di esercizi.
Posta domande e dubbi specifici, spezzoni di codice, e vedrai che l'aiuto non mancherà.

[lucadue]

ma infatti io non ho chiesto la soluzione completa dato che conosco molto bene il regolamento e non mi sognerei mai di infrangerlo. La mia questione era semplicemente, se così si può definire, ottenere un elenco di "azioni" da svolgere in sequenza visto che il mio problema sta proprio nel cominciarlo. Credo che una volta ottenuto questo input avrò sicuramente le idee ben più chiare per implementare l'intero lavoro e se a quel punto avrò dubbi particolari riguardanti uno specifico problema li posterò direttamente. Grazie mille a tutti..

[tapper]

Puoi cominciare con la creazione del processo server (il molo) e con l'algoritmo che gestisce l'arrivo delle navi...... :D


-----------------------------------
Coding Art...

Tetti (http://www.sandrinilegnami.com/1024/tetti3.htm)

[lucadue]

ok grazie mille mi metto al lavoro e appena butto giu qualcosa ve lo posto ;)

[-hide-]

Scopo del progetto è gestire il transito delle imbarcazioni in un porto seguendo le
specifiche qui riportate.
All'inizio dell'esecuzione il porto è vuoto. Vengono generate tramite un processo
un certo numero di imbarcazioni che cercano di entrare nel porto. NB: il numero
di moli è limitato quindi al più 10 imbarcazioni possono soggiornare
contemporaneamente nel porto. Dopo un po' di tempo trascorso a riva (variabile
da imbarcazione a imbarcazione), ogni imbarcazione prende il largo liberando il
molo che occupava.
L'accesso al porto avviene tramite un canale gestito come senso unico alternato.
Ad intervalli regolari vengono fatte entrare alcune imbarcazioni nel porto e poi
fatte uscire alcune imbarcazioni. La durata dei periodi di ingresso ed uscita è
identica. Quindi quando è il turno degli ingressi, le navi ferme al largo iniziano a
entrare, e continuano a farlo per un certo tempo prefissato (a patto che ci siano
moli liberi). Allo scadere del tempo, l'ingresso viene bloccato e si consente alle
navi pronte a partire di uscire, sempre per un tempo prefissato.
Ogni imbarcazione attraccata, avvisa la capitaneria di porto inviando un
messaggio su di una coda (unica per tutte le imbarcazioni e per la capitaneria),
indicante il nome della nave, il carico ed eventuali altre informazioni ritenute
utili. La capitaneria di porto registra tali messaggi in un'area di memoria
condivisa (il registro della capitaneira).
A campione, la capitaneria di porto effettua dei controlli su di alcune
imbarcazioni. A tal fine il processo si forka generando un controllore. Controllore
e nave si scambiano alcune informazioni secondo il protocollo descritto nel
seguito. Il controllore riporta nel registro tutti i passi.
Messaggio 1: da capitaneria a nave: CHECK_START
Messaggio 2: da nave a capitaneira: materiale trasportato + quantità
Messaggio 3: da capitaneira a nave: OK oppure MULTA
La terminazione di tutti i processi figli va intercettata dal corrispodente genitore,
che in tale occorrenza esegue la wait/waitpid.


Questo programma è un vero bordello, già solo leggendo il testo :D
Se non mi studio realmente Fondamenti 2 posso sognarmelo. Dopo che avrò preso la materia in mano tornerò su questo programma, promesso! :Prrr:

[lucadue]

ho pensato di organizzare il tutto in nave.c, capitaneria.c, porto.c e ho iniziato a scrivere nave.c che sara quello che genera le navi e gli assegna i vari attributi

ho creato libporto.h (che verra man mano completato)
#ifndef molo
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <unistd.h>
#define molo

typedef struct {
int quantita;
char merce[10];
int identificatore;
} boat;

#endif

nave.c
#include "libporto.h"

char *get_merce () //metodo che assegna in modo casuale un tipo di merce
{
char *prodotto; //stringa a cui si assegna il tipo di prodotto
int valore; //valore a cui si assegnera il numero casuale
srand (getpid()); //senza di cio il random restituisce sempre lo stesso num ???
valore = rand()%5 + 1; //assegna un valore casuale da 1 a 5 a valore

switch(valore) //assegna il tipo di prodotto in base al numero generato
{
case 1:
prodotto = ("TABACCO");
break;

case 2:
prodotto = ("ACCIAIO");
break;

case 3:
prodotto = ("FERRO");
break;

case 4:
prodotto = ("AUTOMOBILI");
break;

case 5:
prodotto = ("BOMBE");
break;

deafult:
printf("errore \n");
break;
}
return prodotto; //restituisce il prodotto

}

int get_quantita()
{
int t; //tonnellate
srand(getpid()); //senza di cio il random restituisce sempre lo stesso num ???
t = rand()%120 + 1; //assegna un valore casuale da 1 a 120 a valore
return t;
}


ora devo passare a fare il main di nave.c per gestire la creazione delle navi.. cosa mi consigliate di fare?

[lucadue]

ho implementato un primo main

main()
{
int pid; //variabile sulla quale eseguo fork()
int n; //utilizzato per assegnare la wait
boat nave; //dichiarazione variabile nave

pid = fork(); //fork() su pid per creare il figlio

if (!pid) //se pid == 0
{
printf("Sono il figlio %d\n", getpid()); //e' stato creato il figlio del quale stampo il pid
nave.identificatore = getpid(); //assegna all'identificatore della nave l'identificatore del processo
nave.merce = get_merce(); //assegna un tipo random di merce con la funzione get merce
nave.quantita = get_quantita(); //assegna una quantita random di merce con la funzione get quantita
printf("identificatore nave ---> %d \n", 1); //stampa l'identificatore
printf("merce contenuta sulla nave: %s \n", nave.merce); //stampa la merce trasportata
printf("quantità di merce contenuta sulla nave: %d \n", nave.quantita); //stampa la quantita
}

else
printf("padre %d\n", getppid()); //stampo il pid del padre

n = wait(0);

if(n > 0)
printf("Terminato figlio %d\n", n);
}

in questo modo fa quello che deve generandomi una nave con un identificatore, una merce e una quantita...
se voglio espandere questo a dieci navi e non solo una cosa devo modificare? mi date una mano?:help:

[lucadue]

:help:

[lucadue]

edit: il lavoro ora è a questo punto.. come dite di proseguire?

#include "libporto.h"

/* metodo che assegna in modo casuale un tipo di merce */
char *get_merce()
{
char *prodotto; //stringa a cui si assegna il tipo di prodotto
int valore; //valore a cui si assegnerà un numero casuale

srand(getpid()); //senza questo il random restituisce sempre lo stesso num ???
valore = rand() % 5 + 1; //assegna un valore casuale da 1 a 5 alla variabile valore

switch(valore) //assegna il tipo di prodotto in base al numero generato
{
case 1:
prodotto = ("TABACCO");
break;

case 2:
prodotto = ("ACCIAIO");
break;

case 3:
prodotto = ("FERRO");
break;

case 4:
prodotto = ("AUTOMOBILI");
break;

case 5:
prodotto = ("PNEUMATICI");
break;

deafult:
printf("*****ERRORE*****\n");
break;
}

return prodotto; //restituisce il prodotto

}

/* metodo che assegna in modo casuale una quantità ad un carico di merce */
int get_quantita()
{
int t; //variabile contenente il peso della merce in tonnellate
srand(getpid()); //senza questo il random restituisce sempre lo stesso num ???
t = rand() % 120 + 1; //assegna un valore casuale da 1 a 120 alla variabile t

return t; //restituisce le tonnellate
}

/* metodo che crea in modo casuale un numero di navi da un minimo di 1 ad un massimo di 15 */
int get_numnavi()
{
int n; //variabile contenente il numero delle navi
srand(getpid()); //senza questo il random restituisce sempre lo stesso num ???
n = rand() % 15 + 1; //assegna un valore casuale da 1 a 15 alla variabile n

return n; //restituisce il numero di navi
}

/* metodo che crea una nave */
boat crea_nave(int val)
{
boat barca; //struttura contenente la nave da creare

barca.identificatore = getpid(); //assegna all'identificatore della nave l'identificatore del processo
barca.merce = get_merce(); //assegna un tipo random di merce con la funzione get merce
barca.quantita = get_quantita(); //assegna una quantita random di merce con la funzione get quantita
printf("Identificatore nave ---> %d \n", val); //stampa l'identificatore della nave
printf("Merce contenuta sulla nave ---> %s \n", barca.merce); //stampa la merce trasportata dalla nave
printf("Quantità di merce contenuta sulla nave ---> %d tonnellate\n", barca.quantita); //stampa la quantità della merce contenuta sulla nave
fflush(stdout);

return barca; //ritorna la nave appena creata
}

/* metodo che crea la coda di messaggi necessaria per le comunicazioni tra nave e capitaneria */
int crea_codamsg()
{
int q_uid; //variabile alla quale assegnare il risultato della funzione msgget()

q_uid = msgget(ID_CODA, IPC_CREAT | 0666);

if(q_uid == -1)
return 0;
else
return 1;
}

int main()
{ //APERTURA MAIN
int pid; //variabile alla quale assegnare il risultato della funzione fork()
int n; //variabile alla quale assegnare il risultato della funzione wait()
boat nave; //struttura contenente i dati della nave
int i; //variabile contenente l'indice necessario per il ciclo for
int num_navi; //variabile contenente il numero di navi create
int coda_msg; //variabile contenente il valore buon fine o meno del risultato della creazione della coda

coda_msg = crea_codamsg();

if(coda_msg) //if(coda_msg == 1)
{ //APERTURA IF(1)

num_navi = get_numnavi();

for (i = 1; i <= num_navi; ) //ciclo for necessario per creare 10 processi figlio
{ //APERTURA FOR

pid = fork(); //fork() su pid per creare il figlio

if (!pid) //if(pid == 0) entro nel codice del processo figlio
{
printf("\n\nSono il figlio %d \n", getpid()); //e' stato creato il figlio del quale stampo il pid
nave = crea_nave(i);
i = num_navi + 1; //serve per farmi uscire dal ciclo, ovvero il figlio non effettua ulteriori fork()
}

else //if(pid == 1) entro nel codice del processo padre
{
i++; //incremento l'indice del ciclo for per evitare il loop
printf("Sono il padre %d\n", getppid()); //stampo il pid del padre
fflush(stdout);

n = wait(0); //il processo padre aspetta la terminazione del processo figlio
fflush(stdout);

if(n > 0) //se la variabile contiene un numero maggiore di zero (pid del figlio)
printf("Terminato il figlio %d\n", n); //allora significa che il processo figlio è terminato
}
} //CHIUSURA FOR
} //CHIUSURA IF(1)

else //if(coda_msg == 0)
printf("*****ERRORE CREAZIONE CODA*****\n");

return 0;
} //CHIUSURA MAIN



e questa la libporto.h

#ifndef molo
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <unistd.h>
#define molo
#define ID_CODA 1234

typedef struct {
long type;
int npid;
char str[30];
} msg;

typedef struct {
int quantita;
char *merce;
int identificatore;
} boat;

boat crea_nave(int);
char *get_merce();
int get_quantita();
int get_numnavi();
int crea_codamsg();

#endif

[lucadue]

help me per favore

[lucadue]

iniziato a gestire il porto... datemi una mano ad implementare i semafori

#include "libporto.h"

int crea_semafori()
{
int s_uid;
s_uid = semget(ID_SEM, 2, IPC_CREAT | 0666);

if(s_uid == -1)
return -1;
else
return s_uid;
}

int main()
{
int id_semafori;

id_semafori = crea_semafori();

if (crea_semafori >= 0)
{

}

else printf ("*****ERRORE CREAZIONE POOL DI SEMAFORI*****\n");

printf ("l'id del pool dei semafori è %d\n", id_semafori);

return 0;

}

ora che faccio?

[lucadue]

:(

[=KaTaKliSm4=]

che bello sarebbe stato usare gli oggetti in questa situazione eh :D

[lucadue]

se mi date due dritte su come si fa posso modificarlo...