WIP - Se esta arreglando un error de memoria - Anadiendo salida de tiempos

Codes/IOcodes/read_ini.c

@@ -57,6 +57,7 @@ static int handler(void* user, const char* section, const char* name,
 	} else {
           pconfig->phy_dist[act_resize] = COMM_PHY_CPU;
 	}
+
 	free(aux);
         pconfig->actual_resize = pconfig->actual_resize+1; // Ultimo elemento del grupo
 
@@ -130,11 +131,11 @@ void free_config(configuration *user_config) {
  * Imprime por salida estandar toda la informacion que contiene
  * la configuracion pasada como argumento
  */
-void print_config(configuration *user_config, int numP) {
+void print_config(configuration *user_config, int grp) {
   if(user_config != NULL) {
     int i;
-    printf("Config loaded: resizes=%d, matrix=%d, sdr=%d, adr=%d, time=%f || NUMP=%d\n",
-        user_config->resizes, user_config->matrix_tam, user_config->sdr, user_config->adr, user_config->general_time, numP);
+    printf("Config loaded: resizes=%d, matrix=%d, sdr=%d, adr=%d, aib=%d time=%f || grp=%d\n",
+        user_config->resizes, user_config->matrix_tam, user_config->sdr, user_config->adr, user_config->aib, user_config->general_time, grp);
     for(i=0; i<user_config->resizes; i++) {
       printf("Resize %d: Iters=%d, Procs=%d, Factors=%f, Phy=%d\n",
         i, user_config->iters[i], user_config->procs[i], user_config->factors[i], user_config->phy_dist[i]);
@@ -143,6 +144,25 @@ void print_config(configuration *user_config, int numP) {
 }
 
 
+void print_config_group(configuration *user_config, int grp) {
+  if(user_config != NULL) {
+    int parents, sons;
+    parents = sons = 0;
+    if(grp > 0) {
+      parents = user_config->procs[grp-1];
+    }
+    if(grp < user_config->resizes - 1) {
+      sons = user_config->procs[grp+1];
+    }
+
+    printf("Config: matrix=%d, sdr=%d, adr=%d, aib=%d time=%f\n",
+        user_config->matrix_tam, user_config->sdr, user_config->adr, user_config->aib, user_config->general_time);
+    printf("Config Group: iters=%d, factor=%f, phy=%d, procs=%d, parents=%d, sons=%d\n",
+        user_config->iters[grp], user_config->factors[grp], user_config->phy_dist[grp], user_config->procs[grp], parents, sons);
+  }
+}
+
+
 
 //||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| ||
 //||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| ||

Codes/IOcodes/read_ini.h

@@ -18,7 +18,8 @@ typedef struct
 
 configuration *read_ini_file(char *file_name);
 void free_config(configuration *user_config);
-void print_config(configuration *user_config, int numP);
+void print_config(configuration *user_config, int grp);
+void print_config_group(configuration *user_config, int grp);
 
 // MPI Intercomm functions
 void send_config_file(configuration *config_file, int root, MPI_Comm intercomm);

Codes/Main/Main.c

@@ -15,7 +15,7 @@ void TC(int numS);
 int start_redistribution(int numS, MPI_Request **comm_req);
 int check_redistribution(int iter, MPI_Request **comm_req);
 
-void iterate(double *matrix, int n);
+void iterate(double *matrix, int n, int async_comm);
 void computeMatrix(double *matrix, int n);
 void initMatrix(double **matrix, int n);
 
@@ -34,10 +34,15 @@ typedef struct {
 configuration *config_file;
 group_data *group;
 
+// Variables sobre resultados
+//int *iters_time, *iters_type, iter_index;
+
+
 int main(int argc, char *argv[]) {
-    int numP, myId;
+    int numP, myId, i;
+    int thread_level;
 
-    MPI_Init(&argc, &argv);
+    MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &thread_level);
     MPI_Comm_size(MPI_COMM_WORLD, &numP);
     MPI_Comm_rank(MPI_COMM_WORLD, &myId);
 
@@ -61,17 +66,45 @@ int main(int argc, char *argv[]) {
       }
     }
 
-    if(myId== ROOT) print_config(config_file, numP);
+    //iters_time = malloc(config_file->iters[group->grp] * 3 * sizeof(int));
+    //iters_type = malloc(config_file->iters[group->grp] * 3 * sizeof(int));
+    //iter_index = 0;
+
+    //if(myId== ROOT) print_config(config_file, group->grp);
     int res = work();
 
-    if(res) { // Ultimo set de procesos muestra resultados
-	    //RESULTADOS
+    /*
+    if(myId == ROOT) {
+      print_config_group(config_file, group->grp);
+      printf("Titer: ");
+      for(i=0; i<iter_index; i++) {
+        printf("%d ", iters_time[i]);
+      }
+
+      printf("\nTop: ");
+      for(i=0; i<iter_index; i++) {
+        printf("%d ", iters_type[i]);
+      }
+      printf("\n");
+      free(iters_time);
+      free(iters_type);
     }
+    */
+    
+/*
+  int len;
+  char *name = malloc(MPI_MAX_PROCESSOR_NAME * sizeof(char));
+  char *version = malloc(MPI_MAX_LIBRARY_VERSION_STRING * sizeof(char));
+  MPI_Get_processor_name(name, &len);
+  MPI_Get_library_version(version, &len);
+  printf("P%d Nuevo GRUPO %d de %d procs en nodo %s con %s\n", myId, group->grp, numP, name, version);
+*/
 
     free_config(config_file);
     free(group->sync_array);
     free(group->async_array);
     free(group);
+    
 
     MPI_Finalize();
     return 0;
@@ -95,17 +128,19 @@ int work() {
 
   maxiter = config_file->iters[group->grp];
   initMatrix(&matrix, config_file->matrix_tam);
+  state = MAL_COMM_UNINITIALIZED;
 
   for(iter=group->iter_start; iter < maxiter; iter++) {
-    iterate(matrix, config_file->matrix_tam);
+    iterate(matrix, config_file->matrix_tam, state);
   }
 
-  state = checkpoint(iter, MAL_COMM_UNINITIALIZED, &async_comm);
+  state = checkpoint(iter, state, &async_comm);
 
   iter = 0;
   while(state == MAL_ASYNC_PENDING) {
-    iterate(matrix, config_file->matrix_tam);
+    iterate(matrix, config_file->matrix_tam, state);
     iter++;
+
     state = checkpoint(iter, state, &async_comm);
   }
 
@@ -120,7 +155,7 @@ int work() {
  *
  * Si hay datos asincronos a transmitir, primero se comienza a
  * transmitir estos y se termina la funcion. Se tiene que comprobar con
- * llamando a la función de nuevo que se han terminado de enviar //TODO
+ * llamando a la función de nuevo que se han terminado de enviar
  *
  * Si hay ademas datos sincronos a enviar, no se envian aun.
  *
@@ -193,30 +228,31 @@ int check_redistribution(int iter, MPI_Request **comm_req) {
   } else {
     req_completed = &(*comm_req)[1];
   }
-
+ 
   test_err = MPI_Test(req_completed, &completed, MPI_STATUS_IGNORE);
   if (test_err != MPI_SUCCESS && test_err != MPI_ERR_PENDING) {
-    printf("P%d aborting\n", group->myId);
+    printf("P%d aborting -- Test Async\n", group->myId);
     MPI_Abort(MPI_COMM_WORLD, test_err);
   }
 
   MPI_Allreduce(&completed, &all_completed, 1, MPI_INT, MPI_MIN, MPI_COMM_WORLD);
-  if(!all_completed) return MAL_ASYNC_PENDING; // Continue only if asynchronous send has ended  
-
+  if(!all_completed) return MAL_ASYNC_PENDING; // Continue only if asynchronous send has ended 
+  
   iter_send = iter;
+  //MPI_Barrier(MPI_COMM_WORLD); if(group->myId == ROOT){ printf("TEST 2.A0.5\n"); fflush(stdout);} //FIXME BORRAR
   MPI_Bcast(&iter_send, 1, MPI_INT, rootBcast, group->children);
-  if(config_file->sdr > 0) {
+  //MPI_Barrier(MPI_COMM_WORLD); if(group->myId == ROOT){ printf("TEST 2.A0.5a\n"); fflush(stdout);} //FIXME BORRAR
+  if(config_file->sdr > 0) { // Realizar envio sincrono
     send_sync(group->sync_array, config_file->sdr, group->myId, group->numP, ROOT, group->children, numS);
   }
 
   if(config_file->aib == MAL_USE_IBARRIER) {
     MPI_Wait(&(*comm_req)[0], MPI_STATUS_IGNORE); // Indicar como completado el envio asincrono
   }
+    free(*comm_req);
 
   // Desconectar intercomunicador con los hijos
   MPI_Comm_disconnect(&(group->children));
-
-  free(*comm_req);
   return MAL_COMM_COMPLETED;
 }
 
@@ -259,15 +295,33 @@ void Sons_init() {
  * Simula la ejecucción de una iteración de computo en la aplicación
  * que dura al menos un tiempo de "time" segundos.
  */
-void iterate(double *matrix, int n) {
+void iterate(double *matrix, int n, int async_comm) {
   double start_time, actual_time;
   double time = config_file->general_time * config_file->factors[group->grp];
+  int i, operations = 0;
 
   start_time = actual_time = MPI_Wtime();
-  while (actual_time - start_time < time) {
-    computeMatrix(matrix, n);
-    actual_time = MPI_Wtime();
-  }
+  /*
+  if(async_comm == MAL_ASYNC_PENDING) { // Se esta realizando una redistribucion de datos asincrona
+    operations = iters_type[iter_index - 1];
+    for (i=0; i<operations; i++) {
+      computeMatrix(matrix, n);
+      actual_time = MPI_Wtime(); // Guardar tiempos
+    }
+    operations = 0;
+
+  } else { // No hay redistribucion de datos actualmente
+	  */
+    while (actual_time - start_time < time) {
+      computeMatrix(matrix, n);
+      operations++;
+      actual_time = MPI_Wtime(); // Guardar tiempos
+    }
+  //}
+
+  //iters_time[iter_index] = actual_time - start_time;
+  //iters_type[iter_index] = operations;
+  //iters_type++;
 }
 
 /*

Codes/malleability/CommDist.c

@@ -46,13 +46,19 @@ void malloc_comm_array(char **array, int qty, int myId, int numP) {
     struct Dist_data dist_data;
 
     get_dist(qty, myId, numP, &dist_data);
-    *array = malloc(dist_data.tamBl * sizeof(char));
+    if( (*array = malloc(dist_data.tamBl * sizeof(char))) == NULL) {
+      printf("Memory Error (Malloc Arrays(%d))\n", dist_data.tamBl); 
+      exit(1); 
+    }
 
+/*
         int i;
 	for(i=0; i<dist_data.tamBl; i++) {
 	  (*array)[i] = '!' + i + dist_data.ini;
 	}
- //       printf("P%d Tam %d String: %s\n", myId, dist_data.tamBl, *array);
+	
+        printf("P%d Tam %d String: %s\n", myId, dist_data.tamBl, *array);
+*/
 }
 
 //================================================================================
@@ -287,7 +293,7 @@ void send_async_arrays(struct Dist_data dist_data, char *array, int rootBcast, i
       set_counts(i, numP_child, dist_data, counts.counts);
       counts.displs[i] = counts.displs[i-1] + counts.counts[i-1];
     }
-    //print_counts(dist_data, counts.counts, counts.displs, numP_child, "Padres");
+    print_counts(dist_data, counts.counts, counts.displs, numP_child, "Padres");
 
     /* COMUNICACION DE DATOS */
     MPI_Ialltoallv(array, counts.counts, counts.displs, MPI_CHAR, NULL, counts.zero_arr, counts.zero_arr, MPI_CHAR, dist_data.intercomm, comm_req);
@@ -312,7 +318,7 @@ void recv_async_arrays(struct Dist_data dist_data, char *array, int root, int nu
       set_counts(i, numP_parents, dist_data, counts.counts);
       counts.displs[i] = counts.displs[i-1] + counts.counts[i-1];
     }
-    //print_counts(dist_data, counts.counts, counts.displs, numP_parents, "Hijos");
+    print_counts(dist_data, counts.counts, counts.displs, numP_parents, "Hijos");
 
     /* COMUNICACION DE DATOS */
     MPI_Ialltoallv(aux, counts.zero_arr, counts.zero_arr, MPI_CHAR, array, counts.counts, counts.displs, MPI_CHAR, dist_data.intercomm, comm_req);

Codes/malleability/CommDist.h

@@ -4,7 +4,7 @@
 #include <string.h>
 
 #define MAL_COMM_COMPLETED 0
-#define MAL_COMM_UNINITIALIZED 0
+#define MAL_COMM_UNINITIALIZED 2
 #define MAL_ASYNC_PENDING 1
 
 #define MAL_USE_NORMAL 0