Newsgroup: it.comp.lang.c
Titolo: Saluto al ng e problema

Salve a tutto il ng mi chiamo Danilo bottone e sono un "nuovo programmatore"
c. In effetti sto' studiando il c all' univ e penso che lo continuero' anche
per mio "diletto" personale.
Ho subito un problema da porvi, mi e' stato assegnato da svolgere il
problema dei cinque filosofi.
In sostanza ho cinque filosofi con cinque forchette, ogni filosofo deve
avere 2 forchette per mangiare e chiaramente devo evitare deadlock e
compagnia:)
Io ho provato ad implementare la cosa con un unico semaforo a 5 posizioni
che rappresenta le forchette ed a fare in modo che ogni filosofo le prenda e
le posi a coppie.
Purtroppo il mio codice non produce l'output che vorrei dato che esegue i
vari processi in sequenza e non in modo concorrenziale.
Vi posto il mio codice scritto in C sotto linux, vi prego di dargli un
occhiata e possibilmente darmi una soluzione o un link a cui trovare esempi.
Grazie
--------
Inizio codice
--------
/* Simulazione del problema dei cinque filosofi */
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#define   N                5                // numero filosofi
#define   Ritardo_cibo     4                // Ritardo per mangiare
#define   Ritardo_pensa    2                // Ritardo per pensare
int         crea_semaforo(void);
void        filosofo(int io);
void        prende(int io);
void        posa(int io);
void        wait(int s);
void        signal(int s);
struct sembuf vsops;
int id_sem, pid;
int forchette;
int main(void)
{
   int   i;
/* crea forchette */
   forchette = crea_semaforo();
   for (i = 0; i < N ; i++)
   {
/* crea filosofi */
     if (fork() == 0)
     {
       break;
     }
     filosofo(i);
   }
   return 0;
}
int crea_semaforo(void)
{
  id_sem=semget(IPC_PRIVATE,1,IPC_CREAT|0664);
  if (id_sem==-1)
  {
    perror("SEMGET");
    exit(4);
  }
  semctl(id_sem,0,SETVAL,N);
}
/* ciclo del filosofo, input numero filosofo. */
void filosofo(int io)
{
   int i;
   for (i=1 ; i < 2; i++)   /* Un giro per filosofo */
   {
      prende(io);
      printf("Il filosofo %d mangia per la %da volta\n", io, i);
      sleep(Ritardo_cibo);
      posa(io);
      printf("Il filosofo %d posa le forchette e pensa un po'.\n",io);
      sleep(Ritardo_pensa);
      printf("Il filosofo %d finisce di pensare.\n",io);
   }
}
/* Richiedi forchette, input numero filosofo. */
void prende(int io)
{
  wait(forchette);
  printf("Il filosofo %d prende le forchette\n", io);
}
/* Posa forchette, input numero filosofo. */
void posa(int io)
{
   signal(forchette);
}
void wait(int id_sem)
{
   vsops.sem_num=0;
   vsops.sem_op=-2; //wait
   vsops.sem_flg=SEM_UNDO;
   semop(id_sem,&vsops,1);
}
void signal(int id_sem)
{
   vsops.sem_num=0;
   vsops.sem_op=2; //signal
   vsops.sem_flg=SEM_UNDO;
   semop(id_sem,&vsops,1);
}
------
Fine codice
------

 vari processi in sequenza e non in modo concorrenziale.
Perche' non provi a rendere i tempi di pausa casuali?
Ciao,
Luigi

 ha scritto nel messaggio
news:lBZW9.27376$YG2.7...@twister1.libero.it...

In primis grazie della risposta
Ci avevo pensato, infatti stavo per provare la modificca.
Inoltre avevo pensato di mettere in una var intera il numero di forchette e
fare un sem binario su questa variabile e di decrementare o incrementare in
una funzione con il blocco del semaforo.
Che ne dici?
Ciao
Danilo