Foro de elhacker.net

int buzon = atoi(p_memC+334); //el buzon esta correctamente inicializado y guardado en memoria compartida
        int envio, recibo;
 
        struct tipo_mensaje
	{
	        long tipo;
	        char mensaje[20];
	}mensaje;
 
        while(1){
 
	        if(*(p_memC+274) == VERDE)      //aqui se comprueba el estado del semaforo horizontal, el estado lo actualiza automaticamente luz_sem
	        {
		        luz_sem(HORIZONTAL, ROJO);
		        strcpy(mensaje.mensaje, "HORIZ ROJO");
		        mensaje.tipo = HORIZONTALROJO;
		        if((envio = msgsnd(buzon, &mensaje, sizeof(struct tipo_mensaje)-sizeof(long), MSG_NOERROR))==-1)
		        {
		                perror("msgnd");
		                raise(SIGINT);
		        }
	        }else if(*(p_memC+274) == ROJO){
	                mensaje.tipo=VERTICALROJO;
	                if((recibo=msgrcv(buzon, &mensaje, sizeof(struct tipo_mensaje)-sizeof(long), mensaje.tipo, MSG_NOERROR))==-1)
	                {
	                        perror("msgrcv");
	                        raise(SIGINT);
	                }
 
		        luz_sem(HORIZONTAL, VERDE);        //esta es una funcion que esta comprobada que funciona correctamente para cambiar el semaforo de color
 
	        }else if(*(p_memC+275) == VERDE){      //aqui se comprueba el estado del semaforo horizontal, el estado lo actualiza automaticamente luz_sem 
        		luz_sem(VERTICAL, ROJO);
	        	strcpy(mensaje.mensaje, "VERTICAL ROJO");
	        	mensaje.tipo = VERTICALROJO;
	        	if((envio = msgsnd(buzon, &mensaje, sizeof(struct tipo_mensaje)-sizeof(long), MSG_NOERROR))==-1)
	        	{
	        	        perror("msgnd");
	        	        raise(SIGINT);
	        	}
	        }else if(*(p_memC+275) == ROJO){
        	        mensaje.tipo=HORIZONTALROJO;
	                if((recibo=msgrcv(buzon, &mensaje, sizeof(struct tipo_mensaje)-sizeof(long), mensaje.tipo, MSG_NOERROR))==-1)
	                {
	                        perror("msgrcv");
	                        raise(SIGINT);
	                }
	        	luz_sem(VERTICAL, VERDE);
	        }
	}

/* 
  Syncrhonized red-green semaphores
 
  using semaphores...
 
  Safety Invariant:
     0 <= one_sem + two_sem <= 1
 
*/
 
#include <pthread.h>
#include <semaphore.h>
 
 
#include <stdlib.h>  // exit
#include <stdio.h>  // print
#include <unistd.h> // sleep
sem_t one_sem;
sem_t two_sem;
 
 
void* one_thread(void *arg)
{
  for( ; 1 ; )
    {
      if (sem_wait(&one_sem))
	{
	  perror("sem_wait");
	  exit(1);
	}
      printf("one: \t\tRED\n");
      sleep(2);
      if (sem_post(&two_sem))
	{
	  perror("sem_post");
	  exit(1);
	}
      printf("one: \t\tGREEN\n");
    }
}
 
 
void* two_thread(void *arg)
{
  for( ; 1 ; )
    {
      if (sem_wait(&two_sem))
	{
	  perror("sem_wait");
	  exit(1);
	}
      printf("\t\t\t\ttwo: \t\tRED\n");
      sleep(2);
      if (sem_post(&one_sem))
	{
	  perror("sem_post");
	  exit(1);
	}
      printf("\t\t\t\ttwo: \t\tGREEN\n");
    }
}
 
 
int main(int argc, char **args)
{
  pthread_t one,two;
 
  sem_init(&one_sem,0,1);
  sem_init(&two_sem,0,0);
  if (pthread_create(&one, NULL, one_thread, NULL))
    {
      perror("pthread_create");
      exit(1);
    }
  if (pthread_create(&two, NULL, two_thread, NULL))
    {
      perror("pthread_create");
      exit(1);
    }
 
  if (!pthread_join(one,NULL))
    {
      perror("pthread_join");
      exit(1);
    }
 
    if (!pthread_join(two,NULL))
    {
      perror("pthread_join");
      exit(1);
    }
 
}
 

gcc redgreen.c -lpthread -o main && ./main
one: 		RED
one: 		GREEN
				two: 		RED
				two: 		GREEN
one: 		RED
one: 		GREEN
				two: 		RED
				two: 		GREEN
one: 		RED
one: 		GREEN
				two: 		RED
				two: 		GREEN
one: 		RED
one: 		GREEN
				two: 		RED
				two: 		GREEN
one: 		RED
one: 		GREEN
				two: 		RED
				two: 		GREEN
one: 		RED
one: 		GREEN
				two: 		RED
				two: 		GREEN
one: 		RED
one: 		GREEN
				two: 		RED
				two: 		GREEN
one: 		RED

• Podemos emular una especie de semáforo distribuido con colas. Las operaciones P(s) y V(s) son las correspondeintes a rcv(q) y snd(q). Eso si, expresado en C, es un poco críptico, ya que tenemos que ver siempre el retorno de la llamada al sistema
• Al ser utilizado como señalización, el mensaje no precisa de datos. no se precisa comunicar ningún dato, el mismo acto de envío y recepción es suficiente. De ahí que el msg.txt sea de tamñao 0, no es necesario poner "LUZ VERDE" o "LUZ ROJA"...

/* 
  Syncrhonized red-green semaphores
 
  using queues
 
  a queue can act as a distributed semaphore
*/
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
 
#include <sys/stat.h>
#include <fcntl.h>
 
 
 
#include <stdlib.h>  // exit
#include <stdio.h>  // print
#include <unistd.h> // sleep
 
int msq1;
int msq2; // queue descriptors...
 
 
typedef struct msgbuf {
  long mtype;       /* message type, must be > 0 */
  char mtext[0];    /* message data */
} msg;
 
 
void one_process()
{
  struct msgbuf msg = {  1 };
  for( ; 1 ; )
    {
      if (msgrcv(msq1,(void *)&msg,sizeof(msg.mtext),0,0)==-1)
	{
	  perror("msgrcv");
	  exit(EXIT_FAILURE);
	}
      printf("one: \t\tRED\n");
      sleep(2);
      if (msgsnd(msq2,(void *)&msg,sizeof(msg.mtext),0))
	{
	  perror("msgsnd");
	  exit(1);
	}
      printf("one: \t\tGREEN\n");
    }
}
 
 
void two_process()
{
  struct msgbuf msg = { 1 };
  for( ; 1 ; )
    {
      if (msgrcv(msq2,(void *)&msg,sizeof(msg.mtext),0,0)==-1)
	{
	  perror("msgrcv");
	  exit(EXIT_FAILURE);
	}      printf("\t\t\t\ttwo: \t\tRED\n");
      sleep(2);
      if (msgsnd(msq1,(void *)&msg,sizeof(msg.mtext),0))
	{
	  perror("msgsnd");
	  exit(1);
	}
      printf("\t\t\t\ttwo: \t\tGREEN\n");
    }
}
 
 
int main(int argc, char **args)
{
  int pid;
  int msgkey =IPC_PRIVATE;
  struct msgbuf msg = { 1 };
 
  if ((msq1 = msgget(msgkey, IPC_CREAT | 0666 ))==-1)
    {
      perror("msgget");
      exit(EXIT_FAILURE);
    }
 
  if ((msq2 = msgget(msgkey, IPC_CREAT | 0666 ))==-1)
    {
      perror("msgget");
      exit(EXIT_FAILURE);
    }
 
  if (msgsnd(msq1,(void *)&msg,sizeof(msg.mtext),0))
    {
      perror("msgsnd");
      exit(1);
    }  
  pid = fork();
  switch (pid)
    {
    case 0 : // child
      one_process();
      break;
    default: // parent
      two_process();
    }
 
}
 

 gcc redgreen.que.c -o main && ./main
one: 		RED
one: 		GREEN
				two: 		RED
				two: 		GREEN
one: 		RED
one: 		GREEN
				two: 		RED
				two: 		GREEN
one: 		RED
one: 		GREEN
				two: 		RED
				two: 		GREEN
one: 		RED
one: 		GREEN
				two: 		RED
				two: 		GREEN
one: 		RED
one: 		GREEN
				two: 		RED
				two: 		GREEN
one: 		RED
one: 		GREEN
				two: 		RED