Algoritmo de Peterson

 O algoritmo de Peterson é um algoritmo de programação concorrente para exclusão mútua, que permite a dois ou mais processos ou subprocessos compartilharem um recurso sem conflitos, utilizando apenas memória compartilhada para a comunicação.

 Implementação

Implementação do algoritmo em C:

/*
            ***********  ALGORITMO DE PETERSON  ************
*/
 
#include <stdlib.h>
#include "rshmem.h" /*biblioteca não implementada*/
 
void incrementa(int *mem, int k) {
   int i;
   i=*mem; TP
   i=i+k;  TP
   *mem=i;
}
 
int main(int argn, char **argv) {
   FILE *fsal;                   /*Ponteiro para arquivo com saída de resultados*/
   char *marcaFim,               /*Ponteiro fim de zona de memoria compartilhada*/
        *c1,                     /*Variavel de encerramento do processo-pai*/
        *c2;                     /*variável de encerramento do processo-filho*/
   int  *vez,                  /*Variável da vez de entrada do processo*/
        *recurso,                /*Ponteiro a zona de memoria compartilhada*/
        nIteracoes=0;          /*Contador de interações do processo*/
 
   /* Comprovação do número de argumentos */
 
   if(argn!=3){
      printf("Erro na entrada de argumentos/n");
      exit(1);
   }
 
   /* Abertura de arquivos */ 
 
   if((fsal=fopen(argv[2],"a+"))==NULL){
      printf("Erro ao abrir o arquivo de saída\n");
      exit(-1);
   }                /*Comprovação de abertura correta do arquivo de texto de entrada*/
 
   nIteracoes = atoi(argv[1]);
 
   /* criar zona de memoria compartilhada */
 
   if (!crearMemoria())
      fprintf(stderr, "Erro em criarMemoria\n");
 
   recurso  = (int *)  memoria ;
   turno    = (int  *) recurso  + sizeof(int);
   marcaFin = (char *) vez    + sizeof(int) ;
   c1       = (char *) marcaFim + sizeof(char);
   c2       = (char *) c1       + sizeof(char);
   *recurso =   0 ;
   *marcaFin = 'p' ;
   *c1='F';
   *c2='F';
 
   if (0!=fork()) {                               /* Processo Pai */
      int i;
      fprintf(fsal,"P1: SOU O PROCESSO PAI\n"); 
 
      for (i=0; i<nIteracoes; i++){
 
         *c1='T';                                /* Secção */
         *vez=2;                                     /*  de  */
         while (((*c2)=='T') && ((*vez)==2));           /*  entrada */
 
         incrementa(recurso, -5);                          /* Secção */
         fprintf(fsal,"P1: recurso[%d]=%d\n", i, *recurso);       /* critica */
 
         *c1='F';    /* Secção de salida */ 
 
      }/* fim do for */
 
      while (*marcaFim != 'x') ; /* Processo-pai espera processo-filho */
 
      fprintf(fsal,"O recurso que antes valia 0 agora vale %d\n", *recurso);
 
      if (!eliminarMemoria())   /* eliminar memoria compartilhada */
         fprintf(stderr, "erro em eliminarMemoria\n");
 
      exit(0);
 
   }/*if (0!=fork())*/
 
   else   {                                      /* Proceso filho */
      int i;
      fprintf(fsal,"P2: SOU O PROCESSO FILHO\n");
 
      for (i=0; i<nIteracoes; i++) {
 
         *c2='T';                          /* Secção */
         *turno=1;                                 /* de */
         while (((*c1)=='T') && ((*turno)==1));        /* entrada */
 
         incrementa(recurso, 5);                             /* Secção */
         fprintf(fsal,"P2: recurso[%d]=%d\n", i, *recurso);       /* critica */
 
         *c2='F';  /* Secção de salida */
 
      } /* fim do for */
 
  /* Encerramento dos processos */
 
      fclose(fsal);
 
  /* término */
      *marcaFim = 'x';
      exit(0);
 
   }/*fim do else Proceso-filho*/
   //{watchatcha/#}
}/* *************** FIM MAIN ****************** */