Added new features(Commit, allow semi-automatic datatypes). Deleted unneded...

Added new features(Commit, allow semi-automatic datatypes). Deleted unneded codes and minor bug fixes.

Codes/Main/Main.c

@@ -32,11 +32,11 @@ int create_out_file(char *nombre, int *ptr, int newstdout);
 configuration *config_file;
 group_data *group;
 results_data *results;
-MPI_Comm comm;
+MPI_Comm comm, new_comm;
 int run_id = 0; // Utilizado para diferenciar más fácilmente ejecuciones en el análisis
 
 int main(int argc, char *argv[]) {
-    int numP, myId, res;
+    int numP, myId, res, commited;
     int req;
     int im_child;
     size_t i;
@@ -54,6 +54,7 @@ int main(int argc, char *argv[]) {
     MPI_Comm_rank(MPI_COMM_WORLD, &myId);
     MPI_Comm_size(MPI_COMM_WORLD, &numP);
     comm = MPI_COMM_WORLD;
+    new_comm = MPI_COMM_NULL;
 
     if(req != MPI_THREAD_MULTIPLE) {
       printf("No se ha obtenido la configuración de hilos necesaria\nSolicitada %d -- Devuelta %d\n", req, MPI_THREAD_MULTIPLE);
@@ -67,7 +68,6 @@ int main(int argc, char *argv[]) {
     if(!im_child) { //TODO REFACTOR Simplificar inicio
       init_application();
 
-      set_benchmark_grp(group->grp);
       set_benchmark_configuration(config_file);
 
       if(config_file->n_groups > 1) {
@@ -75,19 +75,19 @@ int main(int argc, char *argv[]) {
   	  config_file->groups[group->grp+1].phy_dist, config_file->groups[group->grp+1].rm, config_file->groups[group->grp+1].rs);
         set_children_number(config_file->groups[group->grp+1].procs); // TODO TO BE DEPRECATED
 
-        malleability_add_data(&(group->grp), 1, MAL_INT, 1, 1);
-        malleability_add_data(&run_id, 1, MAL_INT, 1, 1);
-        malleability_add_data(&(group->iter_start), 1, MAL_INT, 1, 1);
-        //malleability_add_data(&(results->exec_start), 1, MAL_DOUBLE, 1, 1);
+        malleability_add_data(&(group->grp), 1, MPI_INT, 1, 0);
+        malleability_add_data(&run_id, 1, MPI_INT, 1, 0);
+        malleability_add_data(&(group->iter_start), 1, MPI_INT, 1, 0);
+        malleability_add_data(&(results->exec_start), 1, MPI_DOUBLE, 1, 0);
 
         if(config_file->sdr) {
 	  for(i=0; i<group->sync_data_groups; i++) {
-            malleability_add_data(group->sync_array[i], group->sync_qty[i], MAL_CHAR, 0, 1);
+            malleability_add_data(group->sync_array[i], group->sync_qty[i], MPI_CHAR, 0, 0);
 	  }
         }
         if(config_file->adr) {
 	  for(i=0; i<group->async_data_groups; i++) {
-            malleability_add_data(group->async_array[i], group->async_qty[i], MAL_CHAR, 0, 0);
+            malleability_add_data(group->async_array[i], group->async_qty[i], MPI_CHAR, 0, 1);
 	  }
         }
       }
@@ -95,32 +95,28 @@ int main(int argc, char *argv[]) {
       MPI_Barrier(comm);
       results->exec_start = MPI_Wtime();
     } else { //Init hijos
-
-      get_malleability_user_comm(&comm);
+      MAM_Commit(&commited, &comm);
       get_benchmark_configuration(&config_file);
 
       // TODO Refactor - Que sea una unica funcion
       // Obtiene las variables que van a utilizar los hijos
       void *value = NULL;
       size_t entries;
-      malleability_get_data(&value, 0, 1, 1);
+      malleability_get_data(&value, 0, 1, 0);
       group->grp = *((int *)value);
 
-      malleability_get_data(&value, 1, 1, 1);
+      malleability_get_data(&value, 1, 1, 0);
       run_id = *((int *)value);
       
-      malleability_get_data(&value, 2, 1, 1);
+      malleability_get_data(&value, 2, 1, 0);
       group->iter_start = *((int *)value);
 
-      //malleability_get_data(&value, 3, 1, 1);
-      //results->exec_start = *((double *)value);
-
       if(config_file->sdr) {
-        malleability_get_entries(&entries, 0, 1);
+        malleability_get_entries(&entries, 0, 0);
         group->sync_qty = (int *) malloc(entries * sizeof(int));
         group->sync_array = (char **) malloc(entries * sizeof(char *));
 	for(i=0; i<entries; i++) {
-          malleability_get_data(&value, i, 0, 1);
+          malleability_get_data(&value, i, 0, 0);
           group->sync_array[i] = (char *)value;
           group->sync_qty[i] = DR_MAX_SIZE;
 	}
@@ -128,11 +124,11 @@ int main(int argc, char *argv[]) {
         group->sync_data_groups = entries;
       }
       if(config_file->adr) {
-        malleability_get_entries(&entries, 0, 0);
+        malleability_get_entries(&entries, 0, 1);
         group->async_qty = (int *) malloc(entries * sizeof(int));
         group->async_array = (char **) malloc(entries * sizeof(char *));
 	for(i=0; i<entries; i++) {
-          malleability_get_data(&value, i, 0, 0);
+          malleability_get_data(&value, i, 0, 1);
           group->async_array[i] = (char *)value;
           group->async_qty[i] = DR_MAX_SIZE;
 	}
@@ -144,6 +140,8 @@ int main(int argc, char *argv[]) {
       results = malloc(sizeof(results_data));
       init_results_data(results, config_file->n_resizes, config_file->n_stages, config_file->groups[group->grp].iters);
 
+      malleability_get_data(&value, 3, 1, 0);
+      results->exec_start = *((double *)value);
     }
 
     //
@@ -151,12 +149,9 @@ int main(int argc, char *argv[]) {
     //
     group->grp = group->grp - 1; // TODO REFACTOR???
     do {
-
-      get_malleability_user_comm(&comm);
       MPI_Comm_size(comm, &(group->numP));
       MPI_Comm_rank(comm, &(group->myId));
       group->grp = group->grp + 1;
-      set_benchmark_grp(group->grp);
 
       if(group->grp != 0) {
         obtain_op_times(0); //Obtener los nuevos valores de tiempo para el computo
@@ -169,12 +164,13 @@ int main(int argc, char *argv[]) {
         set_children_number(config_file->groups[group->grp+1].procs); // TODO TO BE DEPRECATED
 
         if(group->grp != 0) {
-          malleability_modify_data(&(group->grp), 0, 1, MAL_INT, 1, 1);
-          malleability_modify_data(&(group->iter_start), 2, 1, MAL_INT, 1, 1);
+          malleability_modify_data(&(group->grp), 0, 1, MPI_INT, 1, 0);
+          malleability_modify_data(&(group->iter_start), 2, 1, MPI_INT, 1, 0);
         }
       }
 
       res = work();
+
       if(res == MAM_ZOMBIE) break;
       if(res==1) { // Se ha llegado al final de la aplicacion
         MPI_Barrier(comm);
@@ -183,6 +179,9 @@ int main(int argc, char *argv[]) {
 
       print_local_results();
       reset_results_index(results);
+
+      if(comm != MPI_COMM_WORLD) MPI_Comm_free(&comm);
+      comm = new_comm;
     } while(config_file->n_groups > group->grp + 1 && config_file->groups[group->grp+1].sm == MALL_SPAWN_MERGE);
 
     //
@@ -220,7 +219,7 @@ int main(int argc, char *argv[]) {
  * de procesos. En caso contrario se devuelve 0.
  */
 int work() {
-  int iter, maxiter, state, res;
+  int iter, maxiter, state, res, commited;
   int wait_completed = MAM_CHECK_COMPLETION;
 
   maxiter = config_file->groups[group->grp].iters;
@@ -246,6 +245,7 @@ int work() {
 
   
   if(config_file->n_groups == group->grp + 1) res=1;
+  else { MAM_Commit(&commited, &new_comm); }
   if(state == MAM_ZOMBIE) res=state;
   return res;
 }

Codes/malleability/CommDist.h

@@ -6,20 +6,12 @@
 #include <mpi.h>
 #include <string.h>
 #include "malleabilityStates.h"
+#include "malleabilityDataStructures.h"
 
-//#define MAL_COMM_COMPLETED 0
-//#define MAL_COMM_UNINITIALIZED 2
-//#define MAL_ASYNC_PENDING 1
-
-//#define MAL_USE_NORMAL 0
-//#define MAL_USE_IBARRIER 1
-//#define MAL_USE_POINT 2
-//#define MAL_USE_THREAD 3
-
-int sync_communication(char *send, char **recv, int qty, int myId, int numP, int numO, int is_children_group, int comm_type, MPI_Comm comm);
+int sync_communication(void *send, void **recv, int qty, MPI_Datatype datatype, int myId, int numP, int numO, int is_children_group, int comm_type, MPI_Comm comm);
 //int async_communication(char *send, char **recv, int qty, int myId, int numP, int numO, int is_children_group, int red_method, int red_strategies, MPI_Comm comm, MPI_Request **requests, size_t *request_qty);
 
-int async_communication_start(char *send, char **recv, int qty, int myId, int numP, int numO, int is_children_group, int red_method, int red_strategies, MPI_Comm comm, MPI_Request **requests, size_t *request_qty, MPI_Win *win);
+int async_communication_start(void *send, void **recv, int qty, MPI_Datatype datatype, int myId, int numP, int numO, int is_children_group, int red_method, int red_strategies, MPI_Comm comm, MPI_Request **requests, size_t *request_qty, MPI_Win *win);
 int async_communication_check(int myId, int is_children_group, int red_strategies, MPI_Comm comm, MPI_Request *requests, size_t request_qty);
 void async_communication_wait(MPI_Comm comm, MPI_Request *requests, size_t request_qty, int post_ibarrier);
 void async_communication_end(int red_method, int red_strategies, MPI_Request *requests, size_t request_qty, MPI_Win *win);

Codes/malleability/malleabilityDataStructures.c

+#include "malleabilityDataStructures.h"
+
+
+/*
+ * Crea un tipo derivado para mandar las dos estructuras principales
+ * de MaM.
+ */
+void MAM_Def_main_datatype() {
+  int i, counts = 8;
+  int blocklengths[counts];
+  MPI_Aint displs[counts];
+  MPI_Datatype types[counts];
+
+  for(i=0; i<counts; i++) {
+    blocklengths[i] = 1;
+    types[i] = MPI_INT;
+  }
+
+  // Obtener direccion base
+  MPI_Get_address(&(mall_conf->spawn_method), &displs[0]);
+  MPI_Get_address(&(mall_conf->spawn_strategies), &displs[1]);
+  MPI_Get_address(&(mall_conf->spawn_dist), &displs[2]);
+  MPI_Get_address(&(mall_conf->red_method), &displs[3]);
+  MPI_Get_address(&(mall_conf->red_strategies), &displs[4]);
+  MPI_Get_address(&(mall->num_cpus), &displs[5]);
+  MPI_Get_address(&(mall->num_nodes), &displs[6]);
+  MPI_Get_address(&(mall->nodelist_len), &displs[7]);
+
+  MPI_Type_create_struct(counts, blocklengths, displs, types, &mall->struct_type);
+  MPI_Type_commit(&mall->struct_type);
+}
+
+void MAM_Free_main_datatype() {
+  if(mall->struct_type != MPI_DATATYPE_NULL) {
+    MPI_Type_free(&mall->struct_type);
+  }
+}
+
+/*
+ * Comunica datos necesarios de las estructuras
+ * principales de MAM de sources a targets.
+ */
+void MAM_Comm_main_structures(int rootBcast) {
+
+  MPI_Bcast(MPI_BOTTOM, 1, mall->struct_type, rootBcast, mall->intercomm);
+  if(mall->nodelist == NULL) {
+    mall->nodelist = malloc((mall->nodelist_len+1) * sizeof(char));
+    mall->nodelist[mall->nodelist_len] = '\0';
+  }
+  MPI_Bcast(mall->nodelist, mall->nodelist_len, MPI_CHAR, rootBcast, mall->intercomm);
+}

Codes/malleability/malleabilityDataStructures.h

@@ -54,7 +54,6 @@ typedef struct {
   int red_method;
   int red_strategies;
 
-  int grp;
   malleability_times_t *times;
   configuration *config_file;
 } malleability_config_t;
@@ -65,7 +64,8 @@ typedef struct { //FIXME numC_spawned no se esta usando
   MPI_Comm comm, thread_comm;
   MPI_Comm intercomm;
   MPI_Comm user_comm;
-  int dup_user_comm;
+  MPI_Datatype struct_type;
+  int dup_user_comm; //FIXME Borrar
   
   char *name_exec, *nodelist;
   int num_cpus, num_nodes, nodelist_len;
@@ -75,4 +75,10 @@ typedef struct { //FIXME numC_spawned no se esta usando
 malleability_config_t *mall_conf;
 malleability_t *mall;
 
+/* --- FUNCTIONS --- */
+void MAM_Def_main_datatype();
+void MAM_Free_main_datatype();
+void MAM_Comm_main_structures(int rootBcast);
+
+
 #endif

Codes/malleability/malleabilityManager.c

@@ -23,9 +23,6 @@ int check_redistribution(int wait_completed);
 int end_redistribution();
 int shrink_redistribution();
 
-void comm_node_data(int rootBcast, int is_child_group);
-void def_nodeinfo_type(MPI_Datatype *node_type);
-
 int thread_creation();
 int thread_check(int wait_completed);
 void* thread_async_work();
@@ -74,6 +71,7 @@ int init_malleability(int myId, int numP, int root, MPI_Comm comm, char *name_ex
   mall->myId = myId;
   mall->numP = numP;
   mall->root = root;
+  mall->root_parents = -1;
   mall->comm = dup_comm;
   mall->thread_comm = thread_comm;
   mall->user_comm = comm;
@@ -92,6 +90,7 @@ int init_malleability(int myId, int numP, int root, MPI_Comm comm, char *name_ex
 
   zombies_service_init();
   init_malleability_times();
+  MAM_Def_main_datatype();
 
   // Si son el primer grupo de procesos, obtienen los datos de los padres
   MPI_Comm_get_parent(&(mall->intercomm));
@@ -136,6 +135,7 @@ void free_malleability() {
   free(dist_s_data);
   free(dist_a_data);
 
+  MAM_Free_main_datatype();
   free_malleability_times();
   if(mall->comm != MPI_COMM_WORLD) MPI_Comm_free(&(mall->comm));
   if(mall->thread_comm != MPI_COMM_WORLD) MPI_Comm_free(&(mall->thread_comm));
@@ -236,9 +236,9 @@ int malleability_checkpoint(int *mam_state, int wait_completed) {
       }
       break;
 
-    case MALL_SPAWN_ADAPTED:
+    case MALL_SPAWN_ADAPTED: //FIXME Borrar?
       state = shrink_redistribution();
-      if(state == MALL_ZOMBIE) *mam_state = MAM_ZOMBIE;
+      if(state == MALL_ZOMBIE) *mam_state = MAM_ZOMBIE; //TODO Esta no hay que borrarla
       malleability_checkpoint(mam_state, wait_completed);
       break;
 
@@ -256,19 +256,42 @@ int malleability_checkpoint(int *mam_state, int wait_completed) {
   return state;
 }
 
-void MAM_Commit(int *mam_state) {
-  //Hacer borrado de comunicadores no necesarios
-  //Update de comunicadores
-  //Reiniciar algunas estructuras ¿Cuales?
-  //Llamar a funcion de zombies
-  //Devolver el estado de mam
+/*
+ * TODO
+ */
+void MAM_Commit(int *mam_state, MPI_Comm *new_comm) {
+  if(!(state == MALL_COMPLETED || state == MALL_ZOMBIE)) {
+    *mam_state = MALL_DENIED;
+    return;
+  }
+
+  #if USE_MAL_DEBUG
+    if(mall->myId == mall->root) DEBUG_FUNC("Trying to commit", mall->myId, mall->numP); fflush(stdout); MPI_Barrier(MPI_COMM_WORLD);
+  #endif
+  int zombies;
+  MPI_Allreduce(&state, &zombies, 1, MPI_INT, MPI_MIN, mall->intercomm);
+  if(zombies == MALL_ZOMBIE) {
+    zombies_collect_suspended(mall->user_comm, mall->myId, mall->numP, mall->numC, mall->root, NULL, 0, 0);
+  }
+
+  if(mall_conf->spawn_method == MALL_SPAWN_MERGE) { malleability_comms_update(mall->intercomm); }
+  if(mall->intercomm != MPI_COMM_NULL && mall->intercomm != MPI_COMM_WORLD) { 
+    MPI_Comm_disconnect(&(mall->intercomm)); //FIXME Error en OpenMPI + Merge
+  }
+
+  mall->root = mall->root_parents == -1 ? mall->root : mall->root_parents;
+  mall->root_parents = -1;
+  state = MALL_NOT_STARTED;
+  *mam_state = MAM_COMMITED;
+  *new_comm = mall->user_comm;
+
+  #if USE_MAL_DEBUG
+    if(mall->myId == mall->root) DEBUG_FUNC("Reconfiguration has been commited", mall->myId, mall->numP); fflush(stdout); MPI_Barrier(MPI_COMM_WORLD);
+  #endif
 }
 
 // Funciones solo necesarias por el benchmark
 //-------------------------------------------------------------------------------------------------------------
-void set_benchmark_grp(int grp) {
-  mall_conf->grp = grp;
-}
 void set_benchmark_configuration(configuration *config_file) {
   mall_conf->config_file = config_file;
 }
@@ -283,6 +306,8 @@ void malleability_retrieve_times(double *sp_time, double *sy_time, double *asy_t
 }
 
 void set_malleability_configuration(int spawn_method, int spawn_strategies, int spawn_dist, int red_method, int red_strategies) {
+  if(state > MALL_NOT_STARTED) return;
+
   mall_conf->spawn_method = spawn_method;
   mall_conf->spawn_strategies = spawn_strategies;
   mall_conf->spawn_dist = spawn_dist;
@@ -300,6 +325,8 @@ void set_malleability_configuration(int spawn_method, int spawn_strategies, int
  * Tiene que ser llamado despues de setear la config
  */
 void set_children_number(int numC){
+  if(state > MALL_NOT_STARTED) return;
+
   if((mall_conf->spawn_method == MALL_SPAWN_MERGE) && (numC >= mall->numP)) {
     mall->numC = numC;
     mall->numC_spawned = numC - mall->numP;
@@ -335,19 +362,13 @@ void get_malleability_user_comm(MPI_Comm *comm) {
  *
  * Mas informacion en la funcion "add_data".
  *
- * //FIXME Si es constante se debería ir a asincrono, no sincrono
  */
-void malleability_add_data(void *data, size_t total_qty, int type, int is_replicated, int is_constant) {
+void malleability_add_data(void *data, size_t total_qty, MPI_Datatype type, int is_replicated, int is_constant) {
   size_t total_reqs = 0;
 
   if(is_constant) {
     if(is_replicated) {
-      add_data(data, total_qty, type, total_reqs, rep_s_data);
-    } else {
-      add_data(data, total_qty, type, total_reqs, dist_s_data);
-    }
-  } else {
-    if(is_replicated) {
+      total_reqs = 1;
       add_data(data, total_qty, type, total_reqs, rep_a_data); //FIXME total_reqs==0 ??? 
     } else {
       if(mall_conf->red_method  == MALL_RED_BASELINE) {
@@ -361,6 +382,12 @@ void malleability_add_data(void *data, size_t total_qty, int type, int is_replic
       
       add_data(data, total_qty, type, total_reqs, dist_a_data);
     }
+  } else {
+    if(is_replicated) {
+      add_data(data, total_qty, type, total_reqs, rep_s_data);
+    } else {
+      add_data(data, total_qty, type, total_reqs, dist_s_data);
+    }
   }
 }
 
@@ -371,19 +398,13 @@ void malleability_add_data(void *data, size_t total_qty, int type, int is_replic
  * Los datos variables se tienen que modificar cuando quieran ser mandados, no antes
  *
  * Mas informacion en la funcion "modify_data".
- * //FIXME Si es constante se debería ir a asincrono, no sincrono
  */
-void malleability_modify_data(void *data, size_t index, size_t total_qty, int type, int is_replicated, int is_constant) {
+void malleability_modify_data(void *data, size_t index, size_t total_qty, MPI_Datatype type, int is_replicated, int is_constant) {
   size_t total_reqs = 0;
 
   if(is_constant) {
     if(is_replicated) {
-      modify_data(data, index, total_qty, type, total_reqs, rep_s_data);
-    } else {
-      modify_data(data, index, total_qty, type, total_reqs, dist_s_data);
-    }
-  } else {
-    if(is_replicated) {
+      total_reqs = 1;
       modify_data(data, index, total_qty, type, total_reqs, rep_a_data); //FIXME total_reqs==0 ??? 
     } else {    
       if(mall_conf->red_method  == MALL_RED_BASELINE) {
@@ -397,27 +418,32 @@ void malleability_modify_data(void *data, size_t index, size_t total_qty, int ty
       
       modify_data(data, index, total_qty, type, total_reqs, dist_a_data);
     }
+  } else {
+    if(is_replicated) {
+      modify_data(data, index, total_qty, type, total_reqs, rep_s_data);
+    } else {
+      modify_data(data, index, total_qty, type, total_reqs, dist_s_data);
+    }
   }
 }
 
 /*
  * Devuelve el numero de entradas para la estructura de descripcion de 
  * datos elegida.
- * //FIXME Si es constante se debería ir a asincrono, no sincrono
  */
 void malleability_get_entries(size_t *entries, int is_replicated, int is_constant){
   
   if(is_constant) {
     if(is_replicated) {
-      *entries = rep_s_data->entries;
+      *entries = rep_a_data->entries;
     } else {
-      *entries = dist_s_data->entries;
+      *entries = dist_a_data->entries;
     }
   } else {
     if(is_replicated) {
-      *entries = rep_a_data->entries;
+      *entries = rep_s_data->entries;
     } else {
-      *entries = dist_a_data->entries;
+      *entries = dist_s_data->entries;
     }
   }
 }
@@ -428,22 +454,21 @@ void malleability_get_entries(size_t *entries, int is_replicated, int is_constan
  * con la funcion "malleability_add_data()".
  * Es tarea del usuario saber el tipo de esos datos.
  * TODO Refactor a que sea automatico
- * //FIXME Si es constante se debería ir a asincrono, no sincrono
  */
 void malleability_get_data(void **data, size_t index, int is_replicated, int is_constant) {
   malleability_data_t *data_struct;
 
   if(is_constant) {
     if(is_replicated) {
-      data_struct = rep_s_data;
+      data_struct = rep_a_data;
     } else {
-      data_struct = dist_s_data;
+      data_struct = dist_a_data;
     }
   } else {
     if(is_replicated) {
-      data_struct = rep_a_data;
+      data_struct = rep_s_data;
     } else {
-      data_struct = dist_a_data;
+      data_struct = dist_s_data;
     }
   }
 
@@ -464,22 +489,22 @@ void malleability_get_data(void **data, size_t index, int is_replicated, int is_
  */
 void send_data(int numP_children, malleability_data_t *data_struct, int is_asynchronous) {
   size_t i;
-  char *aux_send, *aux_recv;
+  void *aux_send, *aux_recv;
 
   if(is_asynchronous) {
     for(i=0; i < data_struct->entries; i++) {
-      aux_send = (char *) data_struct->arrays[i]; //TODO Comprobar que realmente es un char
+      aux_send = data_struct->arrays[i];
       aux_recv = NULL;
-      async_communication_start(aux_send, &aux_recv, data_struct->qty[i], mall->myId, mall->numP, numP_children, MALLEABILITY_NOT_CHILDREN, mall_conf->red_method, mall_conf->red_strategies, 
-		      mall->intercomm, &(data_struct->requests[i]), &(data_struct->request_qty[i]), &(data_struct->windows[i]));
-      if(aux_recv != NULL) data_struct->arrays[i] = (void *) aux_recv;
+      async_communication_start(aux_send, &aux_recv, data_struct->qty[i], data_struct->types[i], mall->myId, mall->numP, numP_children, MALLEABILITY_NOT_CHILDREN, mall_conf->red_method, 
+		      mall_conf->red_strategies, mall->intercomm, &(data_struct->requests[i]), &(data_struct->request_qty[i]), &(data_struct->windows[i]));
+      if(aux_recv != NULL) data_struct->arrays[i] = aux_recv;
     }
   } else {
     for(i=0; i < data_struct->entries; i++) {
-      aux_send = (char *) data_struct->arrays[i]; //TODO Comprobar que realmente es un char
+      aux_send = data_struct->arrays[i];
       aux_recv = NULL;
-      sync_communication(aux_send, &aux_recv, data_struct->qty[i], mall->myId, mall->numP, numP_children, MALLEABILITY_NOT_CHILDREN, mall_conf->red_method, mall->intercomm);
-      if(aux_recv != NULL) data_struct->arrays[i] = (void *) aux_recv;
+      sync_communication(aux_send, &aux_recv, data_struct->qty[i], data_struct->types[i], mall->myId, mall->numP, numP_children, MALLEABILITY_NOT_CHILDREN, mall_conf->red_method, mall->intercomm);
+      if(aux_recv != NULL) data_struct->arrays[i] = aux_recv;
     }
   }
 }
@@ -491,20 +516,20 @@ void send_data(int numP_children, malleability_data_t *data_struct, int is_async
  */
 void recv_data(int numP_parents, malleability_data_t *data_struct, int is_asynchronous) {
   size_t i;
-  char *aux, aux_s;
+  void *aux, *aux_s = NULL;
 
   if(is_asynchronous) {
     for(i=0; i < data_struct->entries; i++) {
-      aux = (char *) data_struct->arrays[i]; //TODO Comprobar que realmente es un char
-      async_communication_start(&aux_s, &aux, data_struct->qty[i], mall->myId, mall->numP, numP_parents, MALLEABILITY_CHILDREN, mall_conf->red_method, mall_conf->red_strategies, 
+      aux = data_struct->arrays[i];
+      async_communication_start(aux_s, &aux, data_struct->qty[i], data_struct->types[i], mall->myId, mall->numP, numP_parents, MALLEABILITY_CHILDREN, mall_conf->red_method, mall_conf->red_strategies, 
 		      mall->intercomm, &(data_struct->requests[i]), &(data_struct->request_qty[i]), &(data_struct->windows[i]));
-      data_struct->arrays[i] = (void *) aux;
+      data_struct->arrays[i] = aux;
     }
   } else {
     for(i=0; i < data_struct->entries; i++) {
-      aux = (char *) data_struct->arrays[i]; //TODO Comprobar que realmente es un char
-      sync_communication(&aux_s, &aux, data_struct->qty[i], mall->myId, mall->numP, numP_parents, MALLEABILITY_CHILDREN, mall_conf->red_method, mall->intercomm);
-      data_struct->arrays[i] = (void *) aux;
+      aux = data_struct->arrays[i];
+      sync_communication(aux_s, &aux, data_struct->qty[i], data_struct->types[i], mall->myId, mall->numP, numP_parents, MALLEABILITY_CHILDREN, mall_conf->red_method, mall->intercomm);
+      data_struct->arrays[i] = aux;
     }
   }
 }
@@ -537,9 +562,7 @@ void Children_init() {
   }
 
   recv_config_file(mall->root, mall->intercomm, &(mall_conf->config_file));
-  comm_node_data(root_parents, MALLEABILITY_CHILDREN);
-  MPI_Bcast(&(mall_conf->red_method), 1, MPI_INT, root_parents, mall->intercomm);
-  MPI_Bcast(&(mall_conf->red_strategies), 1, MPI_INT, root_parents, mall->intercomm);
+  MAM_Comm_main_structures(root_parents);
 
   #if USE_MAL_DEBUG
     DEBUG_FUNC("Targets have completed spawn step", mall->myId, mall->numP); fflush(stdout); MPI_Barrier(MPI_COMM_WORLD);
@@ -593,15 +616,8 @@ void Children_init() {
     recv_data(numP_parents, dist_s_data, MALLEABILITY_USE_SYNCHRONOUS);
 
     // TODO Crear funcion especifica y anyadir para Asinc
-    // TODO Tener en cuenta el tipo y qty
     for(i=0; i<rep_s_data->entries; i++) {
-      MPI_Datatype datatype;
-      if(rep_s_data->types[i] == MAL_INT) {
-        datatype = MPI_INT;
-      } else {
-        datatype = MPI_CHAR;
-      }
-      MPI_Bcast(rep_s_data->arrays[i], rep_s_data->qty[i], datatype, root_parents, mall->intercomm);
+      MPI_Bcast(rep_s_data->arrays[i], rep_s_data->qty[i], rep_s_data->types[i], root_parents, mall->intercomm);
     } 
     #if USE_MAL_BARRIERS
       MPI_Barrier(mall->intercomm);
@@ -614,15 +630,12 @@ void Children_init() {
 
   // Guardar los resultados de esta transmision
   malleability_times_broadcast(mall->root);
-  if(!is_intercomm) {
-    malleability_comms_update(mall->intercomm);
-  }
 
   #if USE_MAL_BARRIERS
     MPI_Barrier(mall->comm);
   #endif
   mall_conf->times->malleability_end = MPI_Wtime(); // Obtener timestamp de cuando termina maleabilidad
-  MPI_Comm_disconnect(&(mall->intercomm)); //FIXME Error en OpenMPI + Merge
+  state = MALL_COMPLETED;
 
   #if USE_MAL_DEBUG
     DEBUG_FUNC("MaM has been initialized correctly as children", mall->myId, mall->numP); fflush(stdout); MPI_Barrier(MPI_COMM_WORLD);
@@ -690,9 +703,7 @@ int start_redistribution() {
   }
 
   send_config_file(mall_conf->config_file, rootBcast, mall->intercomm);
-  comm_node_data(rootBcast, MALLEABILITY_NOT_CHILDREN);
-  MPI_Bcast(&(mall_conf->red_method), 1, MPI_INT, rootBcast, mall->intercomm);
-  MPI_Bcast(&(mall_conf->red_strategies), 1, MPI_INT, rootBcast, mall->intercomm);
+  if(mall_conf->spawn_method == MALL_SPAWN_BASELINE || mall->numP <= mall->numC) { MAM_Comm_main_structures(rootBcast); }
 
   comm_data_info(rep_a_data, dist_a_data, MALLEABILITY_NOT_CHILDREN, mall->myId, mall->root, mall->intercomm);
   if(dist_a_data->entries || rep_a_data->entries) { // Enviar datos asincronos
@@ -811,15 +822,8 @@ int end_redistribution() {
     send_data(mall->numC, dist_s_data, MALLEABILITY_USE_SYNCHRONOUS);
 
     // TODO Crear funcion especifica y anyadir para Asinc
-    // TODO Tener en cuenta el tipo
     for(i=0; i<rep_s_data->entries; i++) {
-      MPI_Datatype datatype;
-      if(rep_s_data->types[i] == MAL_INT) {
-        datatype = MPI_INT;
-      } else {
-        datatype = MPI_CHAR;
-      }
-      MPI_Bcast(rep_s_data->arrays[i], rep_s_data->qty[i], datatype, rootBcast, mall->intercomm);
+      MPI_Bcast(rep_s_data->arrays[i], rep_s_data->qty[i], rep_s_data->types[i], rootBcast, mall->intercomm);
     } 
     #if USE_MAL_BARRIERS
       MPI_Barrier(mall->intercomm);
@@ -831,17 +835,11 @@ int end_redistribution() {
 
   local_state = MALL_DIST_COMPLETED;
   if(!is_intercomm) { // Merge Spawn
-    if(mall->numP < mall->numC) { // Expand
-      malleability_comms_update(mall->intercomm);
-    } else { // Shrink || Merge Shrink requiere de mas tareas
+    if(mall->numP > mall->numC) { // Shrink || Merge Shrink requiere de mas tareas
       local_state = MALL_SPAWN_ADAPT_PENDING;
     }
   }
 
-  if(mall->intercomm != MPI_COMM_NULL && mall->intercomm != MPI_COMM_WORLD) {
-    MPI_Comm_disconnect(&(mall->intercomm)); //FIXME Error en OpenMPI + Merge
-  }
-
   return local_state;
 }
 
@@ -884,50 +882,6 @@ int shrink_redistribution() {
     }
 }
 
-//======================================================||
-//================PRIVATE FUNCTIONS=====================||
-//=================COMM NODE INFO ======================||
-//======================================================||
-//======================================================||
-//TODO Add comment
-void comm_node_data(int rootBcast, int is_child_group) {
-  MPI_Datatype node_type;
-
-  def_nodeinfo_type(&node_type);
-  MPI_Bcast(mall, 1, node_type, rootBcast, mall->intercomm);
-
-  if(is_child_group) {
-    mall->nodelist = malloc((mall->nodelist_len+1) * sizeof(char));
-    mall->nodelist[mall->nodelist_len] = '\0';
-  }
-  MPI_Bcast(mall->nodelist, mall->nodelist_len, MPI_CHAR, rootBcast, mall->intercomm);
-
-  MPI_Type_free(&node_type);
-}
-
-//TODO Add comment
-void def_nodeinfo_type(MPI_Datatype *node_type) {
-  int i, counts = 3;
-  int blocklengths[3] = {1, 1, 1};
-  MPI_Aint displs[counts], dir;
-  MPI_Datatype types[counts];
-
-  // Rellenar vector types
-  types[0] = types[1] = types[2] = MPI_INT;
-
-  // Rellenar vector displs
-  MPI_Get_address(mall, &dir);
-
-  MPI_Get_address(&(mall->num_cpus), &displs[0]);
-  MPI_Get_address(&(mall->num_nodes), &displs[1]);
-  MPI_Get_address(&(mall->nodelist_len), &displs[2]);
-
-  for(i=0;i<counts;i++) displs[i] -= dir;
-
-  MPI_Type_create_struct(counts, blocklengths, displs, types, node_type);
-  MPI_Type_commit(node_type);
-}
-
 // TODO MOVER A OTRO LADO??
 //======================================================||
 //================PRIVATE FUNCTIONS=====================||
@@ -1021,17 +975,20 @@ void print_comms_state() {
   free(test);
 }
 
+/*
+ * Función solo necesaria en Merge
+ */
 void malleability_comms_update(MPI_Comm comm) {
   if(mall->thread_comm != MPI_COMM_WORLD) MPI_Comm_free(&(mall->thread_comm));
   if(mall->comm != MPI_COMM_WORLD) MPI_Comm_free(&(mall->comm));
-  if(mall->user_comm != MPI_COMM_WORLD) MPI_Comm_free(&(mall->user_comm)); //TODO No es peligroso?
+  if(mall->user_comm != MPI_COMM_WORLD) MPI_Comm_free(&(mall->user_comm)); //TODO No es peligroso? Tendria que hacerlo el usuario
 
   MPI_Comm_dup(comm, &(mall->thread_comm));
   MPI_Comm_dup(comm, &(mall->comm));
   MPI_Comm_dup(comm, &(mall->user_comm)); 
 
-  MPI_Comm_set_name(mall->thread_comm, "MPI_COMM_MALL_THREAD");
-  MPI_Comm_set_name(mall->comm, "MPI_COMM_MALL");
-  MPI_Comm_set_name(mall->user_comm, "MPI_COMM_MALL_USER");
+  MPI_Comm_set_name(mall->thread_comm, "MPI_COMM_MAM_THREAD");
+  MPI_Comm_set_name(mall->comm, "MPI_COMM_MAM");
+  MPI_Comm_set_name(mall->user_comm, "MPI_COMM_MAM_USER");
 }
 

Codes/malleability/malleabilityManager.h

@@ -15,15 +15,14 @@ int init_malleability(int myId, int numP, int root, MPI_Comm comm, char *name_ex
 void free_malleability();
 void indicate_ending_malleability(int new_outside_state);
 int malleability_checkpoint(int *mam_state, int wait_completed);
-void MAM_Commit(int *mam_state);
-void set_benchmark_grp(int grp);
+void MAM_Commit(int *mam_state, MPI_Comm *new_comm);
 
 void set_malleability_configuration(int spawn_method, int spawn_strategies, int spawn_dist, int red_method, int red_strategies);
 void set_children_number(int numC); // TODO TO BE DEPRECATED
 void get_malleability_user_comm(MPI_Comm *comm);
 
-void malleability_add_data(void *data, size_t total_qty, int type, int is_replicated, int is_constant);
-void malleability_modify_data(void *data, size_t index, size_t total_qty, int type, int is_replicated, int is_constant);
+void malleability_add_data(void *data, size_t total_qty, MPI_Datatype type, int is_replicated, int is_constant);
+void malleability_modify_data(void *data, size_t index, size_t total_qty, MPI_Datatype type, int is_replicated, int is_constant);
 void malleability_get_entries(size_t *entries, int is_replicated, int is_constant);
 void malleability_get_data(void **data, size_t index, int is_replicated, int is_constant);
 

Codes/malleability/malleabilityStates.h

@@ -9,7 +9,7 @@
 enum mall_inner_states{MALL_UNRESERVED, MALL_NOT_STARTED, MALL_ZOMBIE, MALL_SPAWN_PENDING, MALL_SPAWN_SINGLE_PENDING, 
 	MALL_SPAWN_SINGLE_COMPLETED, MALL_SPAWN_ADAPT_POSTPONE, MALL_SPAWN_COMPLETED, MALL_DIST_PENDING, MALL_DIST_COMPLETED, 
 	MALL_SPAWN_ADAPT_PENDING, MALL_SPAWN_ADAPTED, MALL_COMPLETED};
-enum mam_states{MAM_UNRESERVED, MAM_NOT_STARTED, MAM_ZOMBIE, MAM_PENDING, MAM_COMPLETED};
+enum mam_states{MAM_UNRESERVED, MAM_NOT_STARTED, MAM_ZOMBIE, MAM_PENDING, MAM_COMPLETED, MAM_COMMITED};
 enum mall_spawn_methods{MALL_SPAWN_BASELINE, MALL_SPAWN_MERGE};
 #define MALL_SPAWN_PTHREAD 2
 #define MALL_SPAWN_SINGLE 3

Codes/malleability/malleabilityTypes.c

@@ -20,7 +20,7 @@ void def_malleability_qty_type(malleability_data_t *data_struct_rep, malleabilit
  * todos los padres. La nueva serie "data" solo representa los datos
  * que tiene este padre.
  */
-void add_data(void *data, size_t total_qty, int type, size_t request_qty, malleability_data_t *data_struct) {
+void add_data(void *data, size_t total_qty, MPI_Datatype type, size_t request_qty, malleability_data_t *data_struct) {
   size_t i;
   
   if(data_struct->entries == 0) {
@@ -49,7 +49,7 @@ void add_data(void *data, size_t total_qty, int type, size_t request_qty, mallea
  * todos los padres. La nueva serie "data" solo representa los datos
  * que tiene este padre.
  */
-void modify_data(void *data, size_t index, size_t total_qty, int type, size_t request_qty, malleability_data_t *data_struct) {
+void modify_data(void *data, size_t index, size_t total_qty, MPI_Datatype type, size_t request_qty, malleability_data_t *data_struct) {
   size_t i;
   
   if(data_struct->entries < index) { // Index does not exist
@@ -81,7 +81,7 @@ void modify_data(void *data, size_t index, size_t total_qty, int type, size_t re
  * unicamente.
  */
 void comm_data_info(malleability_data_t *data_struct_rep, malleability_data_t *data_struct_dist, int is_children_group, int myId, int root, MPI_Comm intercomm) {
-  int is_intercomm, rootBcast = MPI_PROC_NULL;
+  int is_intercomm, rootBcast = MPI_PROC_NULL, type_size;
   size_t i, j;
   MPI_Datatype entries_type, struct_type;
 
@@ -97,7 +97,7 @@ void comm_data_info(malleability_data_t *data_struct_rep, malleability_data_t *d
   def_malleability_entries(data_struct_dist, data_struct_rep, &entries_type);
   MPI_Bcast(MPI_BOTTOM, 1, entries_type, rootBcast, intercomm);
 
-  if(is_children_group && ( data_struct_rep->entries != 0 || data_struct_dist->entries != 0 )) { //FIXME Que pasa si ambos valores son 0?
+  if(is_children_group && ( data_struct_rep->entries != 0 || data_struct_dist->entries != 0 )) {
     init_malleability_data_struct(data_struct_rep, data_struct_rep->entries);
     init_malleability_data_struct(data_struct_dist, data_struct_dist->entries);
   }
@@ -107,14 +107,15 @@ void comm_data_info(malleability_data_t *data_struct_rep, malleability_data_t *d
 
   if(is_children_group) {
     for(i=0; i < data_struct_rep->entries; i++) {
-      data_struct_rep->arrays[i] = (void *) malloc(data_struct_rep->qty[i] * sizeof(int)); //TODO Tener en cuenta que no siempre es int
+      MPI_Type_size(data_struct_rep->types[i], &type_size);
+      data_struct_rep->arrays[i] = (void *) malloc(data_struct_rep->qty[i] * type_size);
       data_struct_rep->requests[i] = (MPI_Request *) malloc(data_struct_rep->request_qty[i] * sizeof(MPI_Request));
       for(j=0; j < data_struct_rep->request_qty[i]; j++) {
         data_struct_rep->requests[i][j] = MPI_REQUEST_NULL;
       }
     }
     for(i=0; i < data_struct_dist->entries; i++) {
-      data_struct_dist->arrays[i] = (void *) NULL;
+      data_struct_dist->arrays[i] = (void *) NULL; // TODO Se podria inicializar aqui?
       data_struct_dist->requests[i] = (MPI_Request *) malloc(data_struct_dist->request_qty[i] * sizeof(MPI_Request));
       for(j=0; j < data_struct_dist->request_qty[i]; j++) {
         data_struct_dist->requests[i][j] = MPI_REQUEST_NULL;
@@ -142,7 +143,7 @@ void init_malleability_data_struct(malleability_data_t *data_struct, size_t size
 
   data_struct->max_entries = size;
   data_struct->qty = (size_t *) malloc(size * sizeof(size_t));
-  data_struct->types = (int *) malloc(size * sizeof(int));
+  data_struct->types = (MPI_Datatype *) malloc(size * sizeof(MPI_Datatype));
   data_struct->request_qty = (size_t *) malloc(size * sizeof(size_t));
   data_struct->requests = (MPI_Request **) malloc(size * sizeof(MPI_Request *));
   data_struct->windows = (MPI_Win *) malloc(size * sizeof(MPI_Win));
@@ -161,14 +162,14 @@ void init_malleability_data_struct(malleability_data_t *data_struct, size_t size
  */
 void realloc_malleability_data_struct(malleability_data_t *data_struct, size_t qty_to_add) {
   size_t i, needed, *qty_aux, *request_qty_aux;
-  int *types_aux;
+  MPI_Datatype *types_aux;
   MPI_Win *windows_aux;
   MPI_Request **requests_aux;
   void **arrays_aux;
 
   needed = data_struct->max_entries + qty_to_add;
   qty_aux = (size_t *) realloc(data_struct->qty, needed * sizeof(int));
-  types_aux = (int *) realloc(data_struct->types, needed * sizeof(int));
+  types_aux = (MPI_Datatype *) realloc(data_struct->types, needed * sizeof(MPI_Datatype));
   request_qty_aux = (size_t *) realloc(data_struct->request_qty, needed * sizeof(int));
   requests_aux = (MPI_Request **) realloc(data_struct->requests, needed * sizeof(MPI_Request *));
   windows_aux = (MPI_Win *) realloc(data_struct->windows, needed * sizeof(MPI_Win));
@@ -184,6 +185,8 @@ void realloc_malleability_data_struct(malleability_data_t *data_struct, size_t q
     arrays_aux[i] = NULL;
   }
 
+  //TODO
+  //if(data_struct->qty != qty_aux && data_struct->qty != NULL) free(data_struct->qty);
   data_struct->qty = qty_aux;
   data_struct->types = types_aux;
   data_struct->request_qty = request_qty_aux;
@@ -199,7 +202,7 @@ void free_malleability_data_struct(malleability_data_t *data_struct) {
   max = data_struct->entries;
   if(max != 0) {
     for(i=0; i<max; i++) {
-      //free(data_struct->arrays[i]); //FIXME Valores alojados con 1 elemento no se liberan?
+      //free(data_struct->arrays[i]); //FIXME Valores alojados con 1 elemento no se liberan? Usar qty? Comprobar si esta alojado por el usuario?
     }
 
     if(data_struct->qty != NULL) {
@@ -281,11 +284,14 @@ void def_malleability_qty_type(malleability_data_t *data_struct_rep, malleabilit
 
   MPI_Get_address((data_struct_rep->qty), &displs[0]);
   MPI_Get_address((data_struct_rep->request_qty), &displs[1]);
-  MPI_Get_address((data_struct_rep->types), &displs[2]);
+  MPI_Get_address((data_struct_rep->types), &displs[2]); // MPI_Datatype uses typedef int to be declared
   MPI_Get_address((data_struct_dist->qty), &displs[3]);
   MPI_Get_address((data_struct_dist->request_qty), &displs[4]);
-  MPI_Get_address((data_struct_dist->types), &displs[5]);
+  MPI_Get_address((data_struct_dist->types), &displs[5]); // MPI_Datatype uses typedef int to be declared
 
   MPI_Type_create_struct(counts, blocklengths, displs, types, new_type);
   MPI_Type_commit(new_type);
 }
+
+
+

Codes/malleability/malleabilityTypes.h

@@ -14,7 +14,7 @@ typedef struct {
   size_t entries; // Indica numero de vectores a comunicar (replicated data)
   size_t max_entries;
   size_t *qty; // Indica numero de elementos en cada subvector de sync_array
-  int *types;
+  MPI_Datatype *types;
 
   // Vector de vectores de request. En cada elemento superior se indican los requests a comprobar para dar por finalizada 
   // la comunicacion de ese dato
@@ -25,8 +25,8 @@ typedef struct {
 
 } malleability_data_t;
 
-void add_data(void *data, size_t total_qty, int type, size_t request_qty, malleability_data_t *data_struct);
-void modify_data(void *data, size_t index, size_t total_qty, int type, size_t request_qty, malleability_data_t *data_struct);
+void add_data(void *data, size_t total_qty, MPI_Datatype type, size_t request_qty, malleability_data_t *data_struct);
+void modify_data(void *data, size_t index, size_t total_qty, MPI_Datatype type, size_t request_qty, malleability_data_t *data_struct);
 void comm_data_info(malleability_data_t *data_struct_rep, malleability_data_t *data_struct_dist, int is_children_group, int myId, int root, MPI_Comm intercomm);
 void free_malleability_data_struct(malleability_data_t *data_struct);