compila

atleta.c

@@ -1,45 +1,49 @@
 #include "atleta.h"
 
 #include <stdlib.h>
+#include <unistd.h>
 
 #include "queue.h"
 #include "globals.h"
 
-void correr(void *arg){
+void *correr(void *arg){
   int id;
   info_atleta *info;
   int etapa_atual = 0;
   int ultimo_anuncio = 0;
-  int vel_atual;
-  int dist_etapa = 0;
-  velocidades velocidades_ref;
-  int km_atual = 0, km_ant = 0;;
+  int vel_atual, vel_dif;
+  int dist_etapa = 0, dist, dist_anuncio;
+  velocidades vel_ref;
+  int km_atual = 0, km_ant = 0, terreno_atual;
+  float random_variance, vel;
   info = (info_atleta *)arg;
-  categoria_atleta[id] = info->categoria;
   id = info->id;
+  categoria_atleta[id] = info->categoria;
   initialized = 1;
   while(!done[id]){
-    while( distancia_percorrida[id] < distancia_etapa[etapa_atual]){
-      if (etapa_atual == etapa_ciclismo){
+    while( dist_etapa < distancia_etapa[etapa_atual] ||
+	   etapa_atual == ETAPA_T1 || 
+	   etapa_atual == ETAPA_T2){
+      if (etapa_atual == ETAPA_CICLISMO){
         km_ant = km_atual;
         km_atual = dist_etapa/1000;
 	terreno_atual = estrada[km_atual].terreno;
-	vel_ref = velocidades_etapa[etapa_ciclismo][terreno_atual];
+	vel_ref = velocidades_etapa[ETAPA_CICLISMO][terreno_atual];
       }
       else
 	vel_ref = velocidades_etapa[etapa_atual][0];
       random_variance = (float)rand()/RAND_MAX;
       vel_dif = vel_ref.max[categoria_atleta[id]] - vel_ref.min[categoria_atleta[id]];
       vel_atual = vel_ref.min[categoria_atleta[id]] + (int)(vel_dif * random_variance);
-      dist = (etapa_atual == etapa_ciclismo ? 1000: (etapa_atual == etapa_T1 || 
-						     etapa_atual == etapa_T2)? 0: 100); 
+      dist = (etapa_atual == ETAPA_CICLISMO ? 1000: (etapa_atual == ETAPA_T1 || 
+						     etapa_atual == ETAPA_T2)? 0: 100); 
       tempo_corrido[id] += vel_atual;
       while (tempo_corrido[id] >= ultimo_anuncio + 1800){
        	vel = (float)dist/(float)vel_atual;
 	dist_anuncio = distancia_percorrida[id] + (int)(vel * (ultimo_anuncio + 1800));
 	while(queueFull(anuncios_posicao[id]))
           sleep(1);
-        queueAdd(queue[id], dist_anuncio);
+        queuePut(anuncios_posicao[id], dist_anuncio);
 	ultimo_anuncio += 1800;
       }
       dist_etapa += dist;
@@ -51,9 +55,9 @@ void correr(void *arg){
     }
     etapa_atual++;
     /*Toda transicao tem que syncar*/
-    if( etapa_atual < num_etapas ){
+    if( etapa_atual < NUM_ETAPAS ){
       dist_etapa = 0;
-      switch(etapa){
+      switch(etapa_atual){
       case ETAPA_T1: 
         PortalT1Ent[id] = 1; break;
       case ETAPA_CICLISMO:
@@ -71,4 +75,5 @@ void correr(void *arg){
     else
       done[id] = 1;
   }
+  return NULL;
 }

atleta.h

@@ -1,6 +1,6 @@
 #ifndef __ATLETA__
 #define __ATLETA__
 
-void correr(void *arg);
+void *correr(void *arg);
 
 #endif /*__ATLETA__*/

classificacao.c

@@ -2,6 +2,7 @@
 
 #include <stdlib.h>
 #include <stdio.h>
+#include <unistd.h>
 
 #include "globals.h"
 #include "queue.h"
@@ -13,15 +14,15 @@ typedef struct{
 
 
 /*Funcao de comparacao pro qsort*/
-int compare_info(cur_atleta_info *atleta1, cur_atleta_info *atleta2){
-  return *atleta2.distancia - *atleta1.distancia;
+static int compare_info(const void *atleta1, const void *atleta2){
+  return ((cur_atleta_info *)atleta2)->distancia - ((cur_atleta_info*)atleta1)->distancia;
 }
 
-void anunciar(void *args){
+void *anunciar(void *args){
   int i, categoria, cur_local_id[NUM_CATEGORIAS];
   cur_atleta_info *info[NUM_CATEGORIAS];
   for(i = 0; i < NUM_CATEGORIAS; i++)
-    info = malloc(participantes_categoria[i] * sizeof (*info));
+    info[i] = malloc(participantes_categoria[i] * sizeof (*(info[i])));
   while (!todos_done){
     for(i = 0; i < NUM_CATEGORIAS; i++)
       cur_local_id[i] = 0;
@@ -36,8 +37,9 @@ void anunciar(void *args){
     }
     for(i = 0; i < NUM_CATEGORIAS; i++){
       qsort((void*)info[i], participantes_categoria[categoria], sizeof(cur_atleta_info), compare_info);
-      fprint(stdout, "%s :\n\n 1 %d\n2 %d\n3 %d\n\n", "Categoria", info[0].id, info[1].id, info[2].id);
+      fprintf(stdout, "%s :\n\n 1 %d\n2 %d\n3 %d\n\n", "Categoria", info[i][0].id, info[i][1].id, info[i][2].id);
       /*anuncia top 3 ou top everyone no debug*/
     }
   }
+  return NULL;
 }

classificacao.h

@@ -1,6 +1,6 @@
 #ifndef __CLASSIFICACAO__
 #define __CLASSIFICACAO__
 
-void anunciar(void *args);
+void *anunciar(void *args);
 
 #endif /*__CLASSIFICACAO__*/

globals.h

@@ -41,11 +41,14 @@ typedef struct{
 pthread_t *atleta;
 pthread_t classificacao;
 pthread_t sync_thread;
-int *PortalT1Ent, *PortalT1Sai, *PortalT2Ent, *PortalT2Sai, 
+int *PortalT1Ent, *PortalT1Sai, *PortalT2Ent, *PortalT2Sai; 
 km_estrada estrada[180];
 Queue *anuncios_posicao;
 
 int *categoria_atleta;
+int todos_done;
+
+int distancia_etapa[NUM_ETAPAS];
 
 int go[NUM_ETAPAS];
 
@@ -54,7 +57,7 @@ int *distancia_percorrida;
 
 velocidades *velocidades_etapa[NUM_ETAPAS];
 
-int num_atletas = 0;
+int num_atletas;
 int participantes_categoria[NUM_CATEGORIAS];
 
 int *done;

main.c

@@ -3,28 +3,33 @@
 #include <time.h>
 #include <pthread.h>
 #include <string.h>
+#include <unistd.h>
 
+#include "classificacao.h"
+#include "atleta.h"
+#include "sync.h"
 #include "queue.h"
 #include "globals.h"
 
 velocidades inicaliza_vels(int hp_min, int hp_max, int mp_min, int mp_max, int ha_min, int ha_max,
                            int ma_min, int ma_max){
   velocidades vel;
-  vel.min[cat_homem_pro] = hp_min;
-  vel.max[cat_homem_pro] = hp_max;
-  vel.min[cat_mulher_pro] = mp_min;
-  vel.max[cat_mulher_pro] = mp_max;
-  vel.min[cat_homem_amador] = ha_min;
-  vel.max[cat_homem_amador] = ha_max;
-  vel.min[cat_mulher_amadora] = ma_min;
-  vel.max[cat_mulher_amadora] = ma_max;
+  vel.min[CAT_HOMEM_PRO] = hp_min;
+  vel.max[CAT_HOMEM_PRO] = hp_max;
+  vel.min[CAT_MULHER_PRO] = mp_min;
+  vel.max[CAT_MULHER_PRO] = mp_max;
+  vel.min[CAT_HOMEM_AMADOR] = ha_min;
+  vel.max[CAT_HOMEM_AMADOR] = ha_max;
+  vel.min[CAT_MULHER_AMADORA] = ma_min;
+  vel.max[CAT_MULHER_AMADORA] = ma_max;
   return vel;
 }
 
-void readfiles(char filename[50]){
+void readfile(char filename[50]){
   char buf[50];
   int option, terrain_type, i, j, kms;
   FILE *file;
+  num_atletas = 0;
   file = fopen(filename, "r");
   fgets(buf, 50, file);
   participantes_categoria[CAT_HOMEM_PRO] = atoi(buf);
@@ -54,6 +59,7 @@ void readfiles(char filename[50]){
 }
 
 void aloca_globais(){
+  int i;
   for (i = 0; i < NUM_CATEGORIAS; i++)
     num_atletas += participantes_categoria[i];
   PortalT1Ent = malloc(num_atletas * sizeof *PortalT1Ent);
@@ -85,7 +91,8 @@ int main(int argc, char **argv){
   int i, j, id_atleta = 0;
   info_atleta info;
   char file[50];
-  if (!strcmp("-debug"), argv[1])
+  void **retval;
+  if (!strcmp("-debug", argv[1]))
     strncpy(file, argv[2], 50);
   else
     strncpy(file, argv[1], 50);
@@ -94,16 +101,23 @@ int main(int argc, char **argv){
   aloca_globais();
   /*mais init*/ 
   srand(time(NULL));
-  if(pthread_create(classificacao), NULL, &anunciar, NULL){
+  todos_done = 0;
+  retval = malloc(sizeof *retval);
+  distancia_etapa[ETAPA_NATACAO] = 3800;
+  distancia_etapa[ETAPA_T1] = 0;
+  distancia_etapa[ETAPA_CICLISMO] = 180000;
+  distancia_etapa[ETAPA_T2] = 0;
+  distancia_etapa[ETAPA_CORRIDA] = 42000;
+  if(pthread_create(&classificacao, NULL, &anunciar, NULL)){
     fprintf(stderr, "Erro ao criar thread da classificacao\n");
     exit(EXIT_FAILURE);
   }
   for (i = 0; i < NUM_CATEGORIAS; i++){
     for (j = 0; j < participantes_categoria[i]; j++){
       initialized = 0;
-      tmpname.categoria = i;
-      tmpname.id = id_atleta;
-      if(pthread_create(atleta[id_atleta], NULL, &correr, &tmpname)){
+      info.categoria = i;
+      info.id = id_atleta;
+      if(pthread_create(&atleta[id_atleta], NULL, &correr, &info)){
 	fprintf(stderr, "Erro ao criar thread do atleta\n");
 	exit(EXIT_FAILURE);
       }
@@ -112,14 +126,14 @@ int main(int argc, char **argv){
       id_atleta++;
     }
   }
-  if(pthread_create(sync_thread, NULL, &sync, NULL)){
+  if(pthread_create(&sync_thread, NULL, &sincroniza, NULL)){
     fprintf(stderr, "Erro ao criar thread de sincronizacao\n");
     exit(EXIT_FAILURE);
   }
   /*anuncia?*/
-  pthread_join(sync);
-  pthread_join(classificacao);
+  pthread_join(sync_thread, retval);
+  pthread_join(classificacao, retval);
   for(i = 0; i < num_atletas; i++)
-    pthread_join(atleta[i]);
+    pthread_join(atleta[i], retval);
   return 0;
 }

sync.c

@@ -1,18 +1,23 @@
 #include "sync.h"
 
 #include <stdlib.h>
+#include <unistd.h>
 
 #include "globals.h"
 
-int compara_tempo(int *i, int*j){
-  return tempo_corrido[*i] - tempo_corrido[*j];
+static int compara_tempo(const void *i, const void *j){
+  int k, l;
+  k =  * (int *)i;
+  l =  * (int *)j;
+  return tempo_corrido[k] - tempo_corrido[l];
 }
 
-void sync(){
-  int i;
+void *sincroniza(void *arg){
+  int i, j;
   int *lista_atletas, *ordem_atletas;
+  ordem_atletas  = malloc(num_atletas * sizeof *ordem_atletas);
   for (i = 1; i < NUM_ETAPAS; i++){
-    for(j = 0; j < NUM_ATLETAS; j++){
+    for(j = 0; j < num_atletas; j++){
       switch(i){
       case ETAPA_T1: 
         lista_atletas = PortalT1Ent; break;
@@ -34,4 +39,8 @@ void sync(){
         tempo_corrido[ordem_atletas[j]] += 3;
     go[i] = 1;
   }
+  while(!done[j])
+    sleep(1);
+  todos_done = 1;
+  return NULL;
 }

sync.h

@@ -1,6 +1,6 @@
 #ifndef __SYNC__
 #define __SYNC__
 
-void sync();
+void *sincroniza(void *arg);
 
 #endif /*__SYNC__*/