problema sincronizzazione: barriera

[zzzzzz]

Salve, dovrei realizzare in c usando semafori e memoria condivisa il meccanismo della barriera in cui abbiamo N processi il cui codice prevede una prima sezione (es. di inizializzazione) e una seconda sezione, e si vuole che tutte le prime sezioni siano eseguite prima di tutte le seconde sezioni, cioè che i processi arrivati al termine della prima sezione proseguano solo dopo che anche gli altri vi sono arrivati.
Io ho realizzato il seguente codice che crea N processi, li addormenta fino a quando non siano arrivati tutti ed N (viene usato per contare i processi una variabile condivisa decrementata da ogni processo), dopodichè (quando la variabile condivisa avrà raggiunto lo 0) li sveglia tutti. Il codice funziona, ma vorrei sapere se può essere considerata una buona soluzione oppure sarebbe stato + funzionale usare 2 semafori aggiungendone 1 che si comporti da contatore dei processi.

#include "semfun.h" // definizione up, down e seminit

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

#define N 5// numero di processi da sincronizzare

int semid, *addr;

/* funzione che si occupa di gestire il meccanismo della barriera */
int barrier(void)
{
 int c;
(*addr)--; //decrementa contatore processi
if(*addr ==0){//sono arrivati tutti gli N processi
   for(c=0;c<=N-1;c++){up(semid,0);}//risveglio processi
            return 0;

}
down(semid,0); /* addormenta questo processo */
}



void proc(int i)
{
  sleep(i);
  printf("Processo %d con pid %d al termine della prima sezione\n",i,getpid());
barrier();
printf("Processo %d con pid %d all'inizio della seconda sezione\n",i,getpid());
}

main()
{
  int pid,i, shmid, val;
/* creazione del semaforo */
 semid = semget(IPC_PRIVATE,1,0600);
if (semid == -1) perror("Creazione semaforo");
 seminit(semid,0,0); //inizializzazione semaforo
/*creazione variabile intera condivisa che avrà funzione di contatore del numero di processi arrivati alla barriera*/
shmid= shmget(IPC_PRIVATE, sizeof(int), 0600);
  if (shmid==-1) perror("mem cond");
addr = (int *) shmat (shmid, 0 ,0);
  if ((int)addr ==-1) perror("attach mem cond");
  *addr=N; 

  for(i=0;i<N;i++)
        if (fork()==0)
                { proc(i); exit(0);};
  for(i=0;i<N;i++)
        { pid=wait(0);
          printf("Terminato processo %d\n",pid);
        }
       /* rimozione semaforo e mem condivisa allocati */
       if (semctl(semid,0,IPC_RMID)==-1) perror("Rimozione semaforo");
       if (shmctl(shmid,IPC_RMID,0)==-1) perror("Rimozione shm");
 }

grazie!!!!!!!!!!!!!!!!!

[zzzzzz]

ragionandoci ancora un po' su ho pensato che, per il codice che ho postato, ci sarebbe anche da usare un semaforo per agire su addr (la variabile in memoria condivisa) in mutua esclusione....quindi, dovendo comunque usare un secondo semaforo, non sarebbe meglio non usare la memoria condivisa e usare un semaforo che agisca da contatore dei processi (che venga inizializzato a N e decrementato fino a 0)???o sbaglio???

help, please!!!!
non riesco a capire quale sia la differenza tra i 2 metodi e quale sarebbe meglio scegliere per risolvere il mio problema!!!!!!!!!!!!!!!!!!!!