vai assim mesmo, e reza

atleta.c

@@ -6,7 +6,7 @@
 #include "queue.h"
 #include "globals.h"
 
-void sync(const int id){
+void sync_atleta(const int id){
   portal P, tmp, aux;
   sem_t *lock;
   int tempo_no_portal;
@@ -27,7 +27,7 @@ void sync(const int id){
     for(tmp = P; tmp->next != NULL; tmp=tmp->next)
       if(tmp->next->id == id){
 	tempo_no_portal = tmp->next->tempo;
-	aux = temp->next;
+	aux = tmp->next;
 	tmp->next = tmp->next->next;
 	free(aux);
 	break;
@@ -67,7 +67,7 @@ int nat_cor(const int id, const int etapa, int minutos_anuncio){
       anuncia(id);
       minutos_anuncio = 0;
     }
-    sync(id);
+    sync_atleta(id);
   }
   while(distancia_percorrida[etapa][id] < distancia_etapa[etapa]){
     distancia = vel;
@@ -92,7 +92,7 @@ int nat_cor(const int id, const int etapa, int minutos_anuncio){
 	}
       distancia_ultima_mudanca += distancia;
       distancia_percorrida[etapa][id] += distancia;
-      sync(id);
+      sync_atleta(id);
     }
   }
   return minutos_anuncio;
@@ -162,7 +162,7 @@ int ciclismo(const int id, int minutos_anuncio){
 	  estrada[km_atual].atletas[1] = id;
 	else if (estrada[km_atual].atletas[2] == -1)
 	  estrada[km_atual].atletas[2] = id;
-	sem_ṕost(&mutex_estrada[km_atual]);
+	sem_post(&mutex_estrada[km_atual]);
 	entrou = 1;vel_ref = velocidades_etapa[etapa][estrada[km_atual].terreno];
 	vel_min = vel_ref.min[categoria];
 	vel_max = vel_ref.max[categoria];
@@ -177,7 +177,7 @@ int ciclismo(const int id, int minutos_anuncio){
 	tempo_corrido[id] += segundos_calc;
       }
     }
-    sync(id);
+    sync_atleta(id);
     if(minutos_anuncio == tempo_anuncio){
       anuncia(id);
       minutos_anuncio = 0;
@@ -187,31 +187,34 @@ int ciclismo(const int id, int minutos_anuncio){
   return minutos_anuncio;
 }
 
-int transicao(const int id, const int portal, int minutos_anuncio){
-  portal P, tmp;
+int transicao(const int id, const int portal_id, int minutos_anuncio){
   sem_t *lock;
-  int tempo_transicao;
-  switch(portal){
+  int tempo_transicao, tempo_espera, etapa;
+  portal P, tmp;
+  switch(portal_id){
   case(0):
-    P = PortalT1Ent; lock = &pt1e; break;
+    P = PortalT1Ent; lock = &pt1e; etapa = ETAPA_T1; break;
   case(1):
-    P = PortalT2Ent; lock = &pt2e; break;
+    P = PortalT2Ent; lock = &pt2e; etapa = ETAPA_T2; break;
   }
   sem_wait(lock);
   tmp = P->next;
   P->next = malloc(sizeof *(P->next));
   P->next->id = id;
-  p->next->tempo = tempo_corrido[id];
+  P->next->tempo = tempo_corrido[id];
   P->next->next = tmp;
-  em_portal[id] = portal+1;
-  sem_ṕost(lock);
-  /*sorteia tempo de estadia*/
+  em_portal[id] = portal_id+1;
+  sem_post(lock);
+  tempo_transicao = ((double)rand()/RAND_MAX) * (velocidades_etapa[etapa][0].max[categoria_atleta[id]] -
+						 velocidades_etapa[etapa][0].min[categoria_atleta[id]]) +
+    velocidades_etapa[etapa][0].min[categoria_atleta[id]];
+
   while(tempo_transicao > 0){
     tempo_espera = 60 - (tempo_corrido[id] % 60);
     if(tempo_transicao >= tempo_espera){
       tempo_corrido[id] += tempo_espera;
       tempo_transicao -= tempo_espera;
-      sync(id);
+      sync_atleta(id);
       minutos_anuncio++;
       if(minutos_anuncio == tempo_anuncio){
 	anuncia(id);
@@ -223,7 +226,7 @@ int transicao(const int id, const int portal, int minutos_anuncio){
       tempo_transicao = 0;
     }
   }
-  switch(portal){
+  switch(portal_id){
   case(0):
     P = PortalT1Sai; lock = &pt1s; break;
   case(1):
@@ -233,9 +236,9 @@ int transicao(const int id, const int portal, int minutos_anuncio){
   tmp = P->next;
   P->next = malloc(sizeof *(P->next));
   P->next->id = id;
-  p->next->tempo = tempo_corrido[id];
+  P->next->tempo = tempo_corrido[id];
   P->next->next = tmp;
-  em_portal[id] = portal+3;
+  em_portal[id] = portal_id+3;
   sem_post(lock);
   return minutos_anuncio;
 }
@@ -249,7 +252,6 @@ void *correr(void *arg){
   id = info->id;
   categoria_atleta[id] = info->categoria;
   sem_post(&init);
-  initialized = 1;
   minutos_anuncio = natacao(id, minutos_anuncio);
   minutos_anuncio = transicao(id, 1, minutos_anuncio);
   minutos_anuncio = ciclismo(id, minutos_anuncio);

classificacao.c

@@ -30,7 +30,7 @@ void *anunciar(void *args){
       cur_local_id[i] = 0;
     for (i = 0; i < num_atletas; i++){
       if(!done[i]){
-	sem_wait(&classificacao_posicao);
+	sem_wait(&classificacao_posicao[i]);
 	categoria = categoria_atleta[i];
 	info[categoria][cur_local_id[categoria]].distancia =
 	  distancia_percorrida[etapa_atual[i]][i];

globals.h

@@ -2,6 +2,7 @@
 #define __GLOBALS__
 
 #include <pthread.h>
+#include <semaphore.h>
 
 #include "queue.h"
 
@@ -38,13 +39,15 @@ typedef struct{
   int atletas[3];
 }km_estrada;
 
+
+typedef struct portalnode *portal; 
+
 struct portalnode{
   int id;
   int tempo;
-  struct portalnode *next;
+  portal next;
 };
 
-typedef struct portalnode *portal; 
 
 pthread_t *atleta;
 pthread_t classificacao;
@@ -56,12 +59,13 @@ sem_t pt1e, pt1s, pt2e, pt2s;
 km_estrada estrada[180];
 sem_t mutex_estrada[180];
 
-sem_t *atleta_posicao;
 sem_t *classificacao_posicao;
 
 int *categoria_atleta;
 int todos_done;
 
+int *em_portal;
+
 int distancia_etapa[NUM_ETAPAS];
 
 int *tempo_corrido;
@@ -77,4 +81,6 @@ int participantes_categoria[NUM_CATEGORIAS];
 
 int *done;
 
+sem_t init;
+
 #endif /*__GLOBALS__*/

main.c

@@ -73,10 +73,44 @@ void aloca_globais(){
   memset(done, 0, num_atletas * sizeof *done);
   tempo_corrido = malloc(num_atletas * sizeof *tempo_corrido);
   memset(tempo_corrido, 0, num_atletas * sizeof *tempo_corrido);
+  em_portal = malloc(num_atletas * sizeof *em_portal);
+  memset(tempo_corrido, 0, num_atletas * sizeof *em_portal);
   for (i = 0; i < NUM_ETAPAS; i++){
     distancia_percorrida[i] = malloc(num_atletas * sizeof *distancia_percorrida);
     memset(distancia_percorrida[i], 0, num_atletas * sizeof *distancia_percorrida);
+    if(i == ETAPA_CICLISMO)
+      velocidades_etapa[i] = malloc(3 * sizeof *velocidades_etapa[i]);
+    else
+      velocidades_etapa[i] = malloc(sizeof *velocidades_etapa[i]);
   }
+  velocidades_etapa[ETAPA_NATACAO][0] = inicializa_vels(6000 /100, 6000 /75, 
+							6000 /120, 6000 / 90, 
+							6000/240, 6000/120, 
+							6000/300, 6000/150);
+  velocidades_etapa[ETAPA_CICLISMO][CICLISMO_PLANO] = inicializa_vels(500 / .6, 550 /.6,
+								      450/.6, 500/.6,
+								      300/.6, 450/.6,
+								      250/.6, 400/.6);
+  velocidades_etapa[ETAPA_CICLISMO][CICLISMO_SUBIDA] = inicializa_vels(300/.6, 400/.6,
+								       200/.6, 300/.6,
+								       120/.6, 200/.6,
+								       100/.6, 200/.6);
+  velocidades_etapa[ETAPA_CICLISMO][CICLISMO_DESCIDA] = inicializa_vels(800/.6, 1000/.6,
+									700/.6, 900/.6,
+									500/.6, 700/.6,
+									500/.6, 650/.6);
+  velocidades_etapa[ETAPA_CORRIDA][0] = inicializa_vels(60000/260, 60000/240, 
+							60000/290, 60000/260, 
+							60000/420, 60000/300, 
+							60000/420, 60000/330);
+  velocidades_etapa[ETAPA_T1][0] = inicializa_vels(90, 150,
+						   90, 150,
+						   150, 330,
+						   150, 390);
+  velocidades_etapa[ETAPA_T2][0] = inicializa_vels(120, 180,
+						   150, 360,
+						   240, 600,
+						   270, 720);
   arrive = malloc(num_atletas * sizeof *arrive);
   for (i = 0; i < num_atletas; i++)
     sem_init(&arrive[i], 0 , 0);
@@ -115,7 +149,7 @@ int main(int argc, char **argv){
   sem_init(&pt2s, 0, 1);
   for(i = 0; i < 180; i++)
     sem_init(&mutex_estrada[i], 0, 1);
-  sem_init(&init, 0, 0)
+  sem_init(&init, 0, 0);
   if(pthread_create(&classificacao, NULL, &anunciar, NULL)){
     fprintf(stderr, "Erro ao criar thread da classificacao\n");
     exit(EXIT_FAILURE);

sync.c

@@ -7,10 +7,13 @@
 
 void *sincroniza(void *arg){
   int i;
-  for(i = 0; i < num_atletas; i++)
-    if(!done[i])
-      sem_wait(&arrive[i]);
-  for(i = 0; i < num_atletas; i++)
-    if(!done[i])
-      sem_post(&libera[i]);
+  while(!todos_done){
+    for(i = 0; i < num_atletas; i++)
+      if(!done[i])
+	sem_wait(&arrive[i]);
+    for(i = 0; i < num_atletas; i++)
+      if(!done[i])
+	sem_post(&libera[i]);
+  }
+  return NULL;
 }