Merge branch 'malleability-refactor' into 'dev'

Malleability focus refactor of Proteo

See merge request martini/malleability_benchmark!5

Codes/malleability/MAM_DataStructures.h

+#ifndef MAM_DATA_STRUCTURES_H
+#define MAM_DATA_STRUCTURES_H
+
+/*
+ * Shows available data structures for inner ussage.
+ */
+#include <stdlib.h>
+#include <stdio.h>
+#include <mpi.h>
+#include <pthread.h>
+#include "MAM_Constants.h"
+
+#define DEBUG_FUNC(debug_string, rank, numP) printf("MaM [P%d/%d]: %s -- %s:%s:%d\n", rank, numP, debug_string, __FILE__, __func__, __LINE__)
+
+/* --- MAM INNER CONSTANTS --- */
+#define MAM_ROOT 0
+enum mam_inner_states{MAM_I_UNRESERVED, MAM_I_NOT_STARTED, MAM_I_RMS_COMPLETED, MAM_I_SPAWN_PENDING, MAM_I_SPAWN_SINGLE_PENDING, 
+	MAM_I_SPAWN_SINGLE_COMPLETED, MAM_I_SPAWN_ADAPT_POSTPONE, MAM_I_SPAWN_COMPLETED, MAM_I_DIST_PENDING, MAM_I_DIST_COMPLETED, 
+	MAM_I_SPAWN_ADAPT_PENDING, MAM_I_USER_START, MAM_I_USER_PENDING, MAM_I_USER_COMPLETED, MAM_I_SPAWN_ADAPTED, MAM_I_COMPLETED};
+
+#define MAM_USE_VALGRIND 1
+#define MAM_USE_EXTRAE 2
+
+#define MAM_VALGRIND_SCRIPT "./worker_valgrind.sh"
+#define MAM_EXTRAE_SCRIPT "./worker_extrae.sh"
+
+/* --- TIME CAPTURE STRUCTURE --- */
+typedef struct {
+  // Spawn, Sync and Async time
+  double spawn_start, spawn_time;
+  double sync_start,  sync_end;
+  double async_start, async_end;
+  double user_start, user_end;
+  double malleability_start, malleability_end;
+
+  MPI_Datatype times_type;
+} malleability_times_t;
+
+/* --- GLOBAL STRUCTURES --- */
+typedef struct {
+  unsigned int spawn_method;
+  unsigned int spawn_dist;
+  unsigned int spawn_strategies;
+  unsigned int red_method;
+  unsigned int red_strategies;
+
+  int external_usage; // Whether a different application should be called by Spawn and which
+
+  malleability_times_t *times;
+} malleability_config_t;
+
+typedef struct { 
+  int myId, numP, numC, zombie;
+  int root, root_collectives;
+  int num_parents, root_parents;
+  pthread_t async_thread;
+  MPI_Comm comm, thread_comm, original_comm;
+  MPI_Comm intercomm, tmp_comm;
+  MPI_Comm *user_comm;
+  MPI_Datatype struct_type;
+
+  // Specific vars for Wait_targets strat
+  int wait_targets_posted;
+  MPI_Request wait_targets;
+  
+  char *name_exec, *nodelist;
+  int num_cpus, num_nodes, nodelist_len;
+  int internode_group;
+} malleability_t;
+
+/* --- VARIABLES --- */
+extern malleability_config_t *mall_conf;
+extern malleability_t *mall;
+extern int state;
+
+/* --- FUNCTIONS --- */
+void MAM_Def_main_datatype();
+void MAM_Free_main_datatype();
+void MAM_Comm_main_structures(MPI_Comm comm, int rootBcast);
+
+void MAM_print_comms_state();
+void MAM_comms_update(MPI_Comm comm);
+
+#endif

Codes/malleability/MAM_Init_Configuration.h

+#ifndef MAM_INIT_CONFIGURATION_H
+#define MAM_INIT_CONFIGURATION_H
+
+#include <mpi.h>
+#include "MAM_Constants.h"
+
+void MAM_Init_configuration();
+void MAM_Set_initial_configuration();
+void MAM_Check_configuration();
+
+#endif

Codes/malleability/MAM_Manager.h

+#ifndef MAM_MANAGER_H
+#define MAM_MANAGER_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <mpi.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <mpi.h>
+
+typedef struct {
+  int numS, numT;
+  int rank_state;
+  MPI_Comm comm;
+} mam_user_reconf_t;
+
+int MAM_Init(int root, MPI_Comm *comm, char *name_exec, void (*user_function)(void *), void *user_args);
+int MAM_Finalize();
+int MAM_Checkpoint(int *mam_state, int wait_completed, void (*user_function)(void *), void *user_args);
+void MAM_Resume_redistribution(int *mam_state);
+
+
+int MAM_Get_Reconf_Info(mam_user_reconf_t *reconf_info);
+
+void MAM_Data_add(void *data, size_t *index, size_t total_qty, MPI_Datatype type, int is_replicated, int is_constant);
+void MAM_Data_modify(void *data, size_t index, size_t total_qty, MPI_Datatype type, int is_replicated, int is_constant);
+void MAM_Data_get_entries(int is_replicated, int is_constant, size_t *entries);
+void MAM_Data_get_pointer(void **data, size_t index, size_t *total_qty, MPI_Datatype *type, int is_replicated, int is_constant);
+#endif

Codes/malleability/MAM_RMS.c

+#define _GNU_SOURCE
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <sched.h>
+#include <mpi.h>
+#include "MAM_RMS.h"
+#include "MAM_DataStructures.h"
+
+
+#if MAM_USE_SLURM
+#include <slurm/slurm.h>
+int MAM_I_slurm_getenv_hosts_info();
+int MAM_I_slurm_getjob_hosts_info();
+#endif
+
+int MAM_I_get_hosts_info();
+int GetCPUCount();
+
+void MAM_check_hosts() {
+  int not_filled = 1;
+  
+  #if MAM_USE_SLURM
+    not_filled = MAM_I_slurm_getjob_hosts_info();
+    if(not_filled) {
+      if(mall->nodelist != NULL) {
+        free(mall->nodelist);
+	mall->nodelist = NULL;
+      }
+
+      not_filled = MAM_I_slurm_getenv_hosts_info();
+    }
+  #endif
+  if(not_filled) {
+    if(mall->nodelist != NULL) {
+      free(mall->nodelist);
+      mall->nodelist = NULL;
+    }
+
+    not_filled = MAM_I_get_hosts_info();
+  }
+
+
+  if(not_filled) {
+    if(mall->myId == mall->root) printf("MAM FATAL ERROR: It has not been possible to obtain the nodelist\n");
+    fflush(stdout);
+    MPI_Abort(mall->comm, -50);
+  }
+
+  #if MAM_DEBUG >= 2
+    if(mall->myId == mall->root) {
+      DEBUG_FUNC("Obtained Nodelist", mall->myId, mall->numP); 
+      printf("NODELIST: %s\nNODE_COUNT: %d NUM_CPUS_PER_NODE: %d\n", mall->nodelist, mall->num_nodes, mall->num_cpus);
+      fflush(stdout); 
+    }
+  #endif
+}
+
+/*
+ * @brief Get if a group of processes uses an internode comunicator
+ *
+ * This function checks the physical distribution of all ranks in the
+ * original communicator passed to MaM. If all of them reside in the
+ * same host, false is returned. True is returned otherwise.
+ *
+ * @return Integer indicating if more than one node is used by the
+ * original communicator (>0) or only one (0).
+ */
+int MAM_Is_internode_group() {
+  int i, name_len, max_name_len, unique_count;
+  int myId, numP;
+  char *my_host, *all_hosts, *tested_host;
+
+  MPI_Comm_rank(mall->original_comm, &myId);
+  MPI_Comm_size(mall->original_comm, &numP);
+
+  unique_count = 0; //First node is not counted
+  if(numP == 1) return unique_count;
+
+  all_hosts = NULL;
+  my_host = (char *) malloc(MPI_MAX_PROCESSOR_NAME * sizeof(char));
+  MPI_Get_processor_name(my_host, &name_len);
+
+  MPI_Allreduce(&name_len, &max_name_len, 1, MPI_INT, MPI_MAX, mall->original_comm);
+  my_host[max_name_len] = '\0';
+  max_name_len++; // Len does not consider terminating character
+  if(myId == MAM_ROOT) {
+    all_hosts = (char *) malloc(numP * max_name_len * sizeof(char));
+  }
+  //FIXME Should be a Gatherv as each host could have unitialised chars between name_len and max_name_len
+  MPI_Gather(my_host, max_name_len, MPI_CHAR, all_hosts, max_name_len, MPI_CHAR, MAM_ROOT, mall->original_comm);
+
+  if(myId == MAM_ROOT) {
+    for (i = 1; i < numP; i++) {
+      tested_host = all_hosts + (i * max_name_len);
+      if (strcmp(my_host, tested_host) != 0) {
+        unique_count++;
+        break;
+      }
+    }
+    free(all_hosts);
+  }
+  MPI_Bcast(&unique_count, 1, MPI_INT, MAM_ROOT, mall->original_comm);
+  free(my_host);
+  return unique_count;
+}
+
+/*
+ * TODO
+ * FIXME Does not consider heterogenous machines for num_cpus
+ * FIXME Always returns 0... -- Perform error checking?
+ */
+int MAM_I_get_hosts_info() {
+  int i, j, name_len, max_name_len, unique_count, *unique_hosts;
+  char *my_host, *all_hosts, *confirmed_host, *tested_host;
+
+  all_hosts = NULL;
+  my_host = (char *) malloc(MPI_MAX_PROCESSOR_NAME * sizeof(char));
+  MPI_Get_processor_name(my_host, &name_len);
+
+  MPI_Allreduce(&name_len, &max_name_len, 1, MPI_INT, MPI_MAX, mall->comm);
+  my_host[max_name_len] = '\0';
+  max_name_len++; // Len does not consider terminating character
+  if(mall->myId == mall->root) {
+    all_hosts = (char *) malloc(mall->numP * max_name_len * sizeof(char));
+    unique_hosts = (int *) malloc(mall->numP * sizeof(int));
+    unique_hosts[0] = 0; //First host will always be unique
+    unique_count = 1;
+  }
+  //FIXME Should be a Gatherv as each host could have unitialised chars between name_len and max_name_len
+  MPI_Gather(my_host, max_name_len, MPI_CHAR, all_hosts, max_name_len, MPI_CHAR, mall->root, mall->comm);
+
+  if(mall->myId == mall->root) {
+    for (i = 1; i < mall->numP; i++) {
+      for (j = 0; j < unique_count; j++) {
+	tested_host = all_hosts + (i * max_name_len);
+	confirmed_host = all_hosts + (unique_hosts[j] * max_name_len);
+        if (strcmp(tested_host, confirmed_host) != 0) {
+	  unique_hosts[unique_count] = i;
+          unique_count++;
+          break;
+        }
+      }
+    }
+
+    mall->num_nodes = unique_count;
+    mall->num_cpus = GetCPUCount(); 
+    mall->nodelist_len = unique_count*max_name_len;
+    mall->nodelist = (char *) malloc(mall->nodelist_len * sizeof(char));
+
+    strcpy(mall->nodelist, ""); //FIXME Strcat can be very inneficient...
+    for (i = 0; i < unique_count; i++) {
+      confirmed_host = all_hosts + (unique_hosts[i] * max_name_len);
+      strcat(mall->nodelist, confirmed_host);
+      if (i < unique_count - 1) {
+        strcat(mall->nodelist, ",");
+      }
+    }
+
+    free(all_hosts);
+    free(unique_hosts);
+  }
+
+  free(my_host);
+  return 0;
+}
+
+/*
+ * @brief Get the total number of CPUs available to the process.
+ *
+ * This function uses sched_getaffinity to obtain the CPU affinity of the current process
+ * and counts the number of CPUs in the affinity set. It adjusts the loop based on the
+ * maximum number of CPUs allowed on the system.
+ *
+ * @return The total number of CPUs available to the process.
+ *
+ * Code obtained from: https://stackoverflow.com/questions/4586405/how-to-get-the-number-of-cpus-in-linux-using-c
+ * The code has been slightly modified.
+ */
+int GetCPUCount() {
+  cpu_set_t cs;
+  CPU_ZERO(&cs);
+  sched_getaffinity(0, sizeof(cs), &cs);
+
+  int count = 0;
+  int max_cpus = sysconf(_SC_NPROCESSORS_ONLN);
+
+  for (int i = 0; i < max_cpus; i++) {
+      if (CPU_ISSET(i, &cs)) {
+          count++;
+      } else {
+          break;
+      }
+  }
+  return count;
+}
+
+#if MAM_USE_SLURM
+/*
+ * TODO
+ */
+int MAM_I_slurm_getenv_hosts_info() {
+  char *tmp = NULL, *tmp_copy, *token;
+  int cpus, count;
+  //int i, *cpus_counts, *nodes_counts, *aux;
+  
+  tmp = getenv("SLURM_JOB_NUM_NODES");
+  if(tmp == NULL) return 1;
+  mall->num_nodes = atoi(tmp);
+  tmp = NULL;
+
+  tmp = getenv("SLURM_JOB_NODELIST");
+  if(tmp == NULL) return 1;
+  mall->nodelist_len = strlen(tmp)+1;
+  mall->nodelist = (char *) malloc(mall->nodelist_len * sizeof(char));
+  strcpy(mall->nodelist, tmp);
+  tmp = NULL;
+
+
+  //EXAMPLE - SLURM_JOB_CPUS_PER_NODE='72(x2),36'
+  //It indicates two nodes have 72 CPUs each and third has 36 cpus
+  tmp = getenv("SLURM_JOB_CPUS_PER_NODE");
+  if(tmp == NULL) return 1;
+
+  tmp_copy = (char *) malloc((strlen(tmp)+1) * sizeof(char));
+  strcpy(tmp_copy, tmp);
+  token = strtok(tmp_copy, ",");
+  //TODO When MaM considers heteregenous allocations, these will be needed instead of num_cpus.
+  //cpus_counts = (int *) malloc(mall->num_nodes * sizeof(int));
+  //nodes_counts = (int *) malloc(mall->num_nodes * sizeof(int));
+  //i = 0;
+  mall->num_cpus = 0;
+
+  while (token != NULL) {
+    // If actual token contains only one node, the second portion
+    // does not appear and sscanf does not modify "count"
+    // First portion --> "%d"
+    // Second portion -> "(x%d)"
+    count = 1;
+    if (sscanf(token, "%d(x%d)", &cpus, &count) >= 1) {
+      mall->num_cpus = cpus; // num_cpus stores the amount of cores per cpu
+      //cpus_per_node[i] = cpus;
+      //nodes_count[i] = count;
+      //i++;
+    }
+    token = strtok(NULL, ",");
+  }
+  /*
+  if(i < mall->num_nodes) {
+    aux = (int *) realloc(cpus_per_node, i * sizeof(int));
+    if(cpus_per_node != aux && cpus_per_node != NULL) free(cpus_per_node);
+    cpus_per_node = aux;
+
+    aux = (int *) realloc(nodes_counts, i * sizeof(int));
+    if(nodes_count != aux && nodes_count != NULL) free(nodes_count);
+    nodes_count = aux;
+  }
+  */
+
+  free(tmp_copy);
+  return 0;
+}
+
+/*
+ * TODO
+ * FIXME Does not consider heterogenous machines
+ */
+int MAM_I_slurm_getjob_hosts_info() {
+  int jobId, err;
+  char *tmp = NULL;
+  job_info_msg_t *j_info;
+  slurm_job_info_t last_record;
+
+  tmp = getenv("SLURM_JOB_ID");
+  if(tmp == NULL) return 1;
+  jobId = atoi(tmp);
+
+  err = slurm_load_job(&j_info, jobId, 1);
+  if(err) return err;
+  last_record = j_info->job_array[j_info->record_count - 1];
+
+  mall->num_nodes = last_record.num_nodes;
+  mall->num_cpus = last_record.num_cpus / last_record.num_nodes;
+
+  mall->nodelist_len = strlen(last_record.nodes)+1;
+  mall->nodelist = (char *) malloc(mall->nodelist_len * sizeof(char));
+  strcpy(mall->nodelist, last_record.nodes);
+
+  slurm_free_job_info_msg(j_info);
+  return 0;
+}
+#endif
+
+//TODO REFACTOR PARA CUANDO SE COMUNIQUE CON RMS
+    // Get Slurm job info
+    //int jobId;
+    //char *tmp;
+    //job_info_msg_t *j_info;
+    //slurm_job_info_t last_record;
+    //tmp = getenv("SLURM_JOB_ID");
+    //jobId = atoi(tmp);
+    //slurm_load_job(&j_info, jobId, 1);
+    //last_record = j_info->job_array[j_info->record_count - 1];
+    // Free JOB INFO
+    //slurm_free_job_info_msg(j_info);

Codes/malleability/MAM_RMS.h

+#ifndef MAM_RMS_H
+#define MAM_RMS_H
+
+void MAM_check_hosts();
+int MAM_Is_internode_group();
+
+#endif

Codes/malleability/MAM_Times.c

+#include "MAM_Times.h"
+#include "MAM_DataStructures.h"
+
+void def_malleability_times(MPI_Datatype *new_type);
+
+void init_malleability_times() {
+  #if MAM_DEBUG
+    DEBUG_FUNC("Initializing recording structure", mall->myId, mall->numP); fflush(stdout); MPI_Barrier(mall->comm);
+  #endif
+
+  mall_conf->times = (malleability_times_t *) malloc(sizeof(malleability_times_t));
+  if(mall_conf->times == NULL) {
+    perror("Error al crear la estructura de tiempos interna para maleabilidad\n");
+    MPI_Abort(MPI_COMM_WORLD, -5);
+  }
+
+  reset_malleability_times();
+  def_malleability_times(&mall_conf->times->times_type);
+
+  #if MAM_DEBUG
+    DEBUG_FUNC("Initialized recording structure", mall->myId, mall->numP); fflush(stdout); MPI_Barrier(mall->comm);
+  #endif
+}
+
+
+void reset_malleability_times() {
+  malleability_times_t *times = mall_conf->times;
+  times->spawn_start = 0; times->sync_start = 0; times->async_start = 0; times->user_start = 0; times->malleability_start = 0;
+  times->sync_end = 0; times->async_end = 0; times->user_end = 0; times->malleability_end = 0;
+  times->spawn_time = 0;
+}
+
+void free_malleability_times() {
+  #if MAM_DEBUG
+    DEBUG_FUNC("Freeing recording structure", mall->myId, mall->numP); fflush(stdout);
+  #endif
+  if(mall_conf->times != NULL) {
+    if(mall_conf->times->times_type != MPI_DATATYPE_NULL) {
+      MPI_Type_free(&mall_conf->times->times_type);
+      mall_conf->times->times_type = MPI_DATATYPE_NULL;
+    }
+    free(mall_conf->times);
+  }
+  #if MAM_DEBUG
+    DEBUG_FUNC("Freed recording structure", mall->myId, mall->numP); fflush(stdout);
+  #endif
+}
+
+/*
+ * @brief Returns the times used for the different steps of last reconfiguration.
+ *
+ * This function is intended to be called when a reconfiguration has ended. 
+ * It is designed to provide the necessary information for the user to perform data redistribution.
+ *
+ * Parameters:
+ *  - double *sp_time:   A pointer where the spawn time will be saved.
+ *  - double *sy_time:   A pointer where the sychronous data redistribution time will be saved.
+ *  - double *asy_time:  A pointer where the asychronous data redistribution time will be saved.
+ *  - double *user_time: A pointer where the user data redistribution time will be saved.
+ *  - double *mall_time: A pointer where the malleability time will be saved.
+ */
+void MAM_Retrieve_times(double *sp_time, double *sy_time, double *asy_time, double *user_time, double *mall_time) {
+  malleability_times_t *times = mall_conf->times;
+  *sp_time = times->spawn_time;
+  *sy_time = times->sync_end - times->sync_start;
+  *asy_time = times->async_end - times->async_start;
+  *user_time = times->user_end - times->user_start;
+  *mall_time = times->malleability_end - times->malleability_start;
+}
+
+void malleability_times_broadcast(int root) {
+  MPI_Bcast(mall_conf->times, 1, mall_conf->times->times_type, root, mall->intercomm);
+}
+
+void def_malleability_times(MPI_Datatype *new_type) {
+  int i, counts = 5;
+  int blocklengths[counts];
+  MPI_Aint displs[counts], dir;
+  MPI_Datatype types[counts];
+
+  blocklengths[0] = blocklengths[1] = blocklengths[2] = blocklengths[3] = blocklengths[4] = 1;
+  types[0] = types[1] =  types[2] = types[3] = types[4] = MPI_DOUBLE;
+
+  // Se pasa el vector a traves de la direccion de "mall_conf"
+  // Rellenar vector displs
+  MPI_Get_address(mall_conf->times, &dir);
+
+  // Obtener direccion base
+  MPI_Get_address(&(mall_conf->times->spawn_time), &displs[0]);
+  MPI_Get_address(&(mall_conf->times->sync_start), &displs[1]);
+  MPI_Get_address(&(mall_conf->times->async_start), &displs[2]);
+  MPI_Get_address(&(mall_conf->times->user_start), &displs[3]);
+  MPI_Get_address(&(mall_conf->times->malleability_start), &displs[4]);
+
+  for(i=0;i<counts;i++) displs[i] -= dir;
+
+  MPI_Type_create_struct(counts, blocklengths, displs, types, new_type);
+  MPI_Type_commit(new_type);
+}

Codes/malleability/MAM_Times.h

+#ifndef MAM_TIMES_H
+#define MAM_TIMES_H
+
+#include <mpi.h>
+
+void init_malleability_times();
+void reset_malleability_times();
+void free_malleability_times();
+
+void malleability_times_broadcast(int root);
+
+void MAM_I_retrieve_times(double *sp_time, double *sy_time, double *asy_time, double *user_time, double *mall_time);
+
+#endif

Codes/malleability/MAM_Times_retrieve.h

+
+#ifndef MAM_TIMES_RETRIEVE_H
+#define MAM_TIMES_RETRIEVE_H
+
+void MAM_Retrieve_times(double *sp_time, double *sy_time, double *asy_time, double *user_time, double *mall_time);
+#endif

Codes/malleability/malleabilityTypes.c → Codes/malleability/MAM_Types.c

-#include "malleabilityTypes.h"
+#include "MAM_Types.h"
+#include "MAM_DataStructures.h"
+#include "MAM_Configuration.h"
 
 
 void init_malleability_data_struct(malleability_data_t *data_struct, size_t size);
@@ -20,13 +22,13 @@ 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) {
-    init_malleability_data_struct(data_struct, MALLEABILITY_INIT_DATA_QTY);
+    init_malleability_data_struct(data_struct, MAM_TYPES_INIT_DATA_QTY);
   } else if(data_struct->entries == data_struct->max_entries) {
-    realloc_malleability_data_struct(data_struct, MALLEABILITY_INIT_DATA_QTY);
+    realloc_malleability_data_struct(data_struct, MAM_TYPES_INIT_DATA_QTY);
   }
   
   data_struct->qty[data_struct->entries] = total_qty;
@@ -49,7 +51,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
@@ -80,41 +82,34 @@ void modify_data(void *data, size_t index, size_t total_qty, int type, size_t re
  * En el argumento "root" todos tienen que indicar quien es el proceso raiz de los padres
  * 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;
+void comm_data_info(malleability_data_t *data_struct_rep, malleability_data_t *data_struct_dist, int is_children_group) {
+  int type_size;
   size_t i, j;
   MPI_Datatype entries_type, struct_type;
 
-
-  MPI_Comm_test_inter(intercomm, &is_intercomm);
-  if(is_intercomm && !is_children_group) {
-    rootBcast = myId == root ? MPI_ROOT : MPI_PROC_NULL;
-  } else {
-    rootBcast = root;
-  }
-
   // Mandar primero numero de entradas
   def_malleability_entries(data_struct_dist, data_struct_rep, &entries_type);
-  MPI_Bcast(MPI_BOTTOM, 1, entries_type, rootBcast, intercomm);
+  MPI_Bcast(MPI_BOTTOM, 1, entries_type, mall->root_collectives, mall->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);
   }
 
   def_malleability_qty_type(data_struct_dist, data_struct_rep, &struct_type);
-  MPI_Bcast(MPI_BOTTOM, 1, struct_type, rootBcast, intercomm);
+  MPI_Bcast(MPI_BOTTOM, 1, struct_type, mall->root_collectives, mall->intercomm);
 
   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); //FIXME This memory is not freed -- How should be done?
       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 +137,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));
@@ -150,6 +145,7 @@ void init_malleability_data_struct(malleability_data_t *data_struct, size_t size
 
   for(i=0; i<size; i++) { //calloc and memset does not ensure a NULL value
     data_struct->requests[i] = NULL;
+    data_struct->windows[i] = MPI_WIN_NULL;
     data_struct->arrays[i] = NULL;
   }
 }
@@ -161,14 +157,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));
@@ -181,9 +177,18 @@ void realloc_malleability_data_struct(malleability_data_t *data_struct, size_t q
 
   for(i=data_struct->max_entries; i<needed; i++) { //realloc does not ensure a NULL value
     requests_aux[i] = NULL;
+    windows_aux[i] = MPI_WIN_NULL;
     arrays_aux[i] = NULL;
   }
 
+  // Check if old array can be freed
+  if(data_struct->qty != qty_aux && data_struct->qty != NULL) free(data_struct->qty);
+  if(data_struct->types != types_aux && data_struct->types != NULL) free(data_struct->types);
+  if(data_struct->request_qty != request_qty_aux && data_struct->request_qty != NULL) free(data_struct->request_qty);
+  if(data_struct->requests != requests_aux && data_struct->requests != NULL) free(data_struct->requests);
+  if(data_struct->windows != windows_aux && data_struct->windows != NULL) free(data_struct->windows);
+  if(data_struct->arrays != arrays_aux && data_struct->arrays != NULL) free(data_struct->arrays);
+
   data_struct->qty = qty_aux;
   data_struct->types = types_aux;
   data_struct->request_qty = request_qty_aux;
@@ -198,10 +203,6 @@ 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?
-    }
-
     if(data_struct->qty != NULL) {
       free(data_struct->qty);
     }
@@ -248,10 +249,11 @@ void def_malleability_entries(malleability_data_t *data_struct_rep, malleability
   int counts = 2;
   int blocklengths[counts];
   MPI_Aint displs[counts];
-  MPI_Datatype types[counts];
+  MPI_Datatype types[counts], type_size_t;
+  MPI_Type_match_size(MPI_TYPECLASS_INTEGER, sizeof(size_t), &type_size_t);
 
   blocklengths[0] = blocklengths[1] = 1;
-  types[0] = types[1] = MPI_UNSIGNED_LONG;
+  types[0] = types[1] = type_size_t;
 
   // Obtener direccion base
   MPI_Get_address(&(data_struct_rep->entries), &displs[0]);
@@ -272,20 +274,24 @@ void def_malleability_qty_type(malleability_data_t *data_struct_rep, malleabilit
   int counts = 6;
   int blocklengths[counts];
   MPI_Aint displs[counts];
-  MPI_Datatype types[counts];
+  MPI_Datatype types[counts], type_size_t;
+  MPI_Type_match_size(MPI_TYPECLASS_INTEGER, sizeof(size_t), &type_size_t);
 
-  types[0] = types[1] = types[3] = types[4] = MPI_UNSIGNED_LONG;
+  types[0] = types[1] = types[3] = types[4] = type_size_t;
   types[2] = types[5] = MPI_INT;
   blocklengths[0] = blocklengths[1] = blocklengths[2] = data_struct_rep->entries;
   blocklengths[3] = blocklengths[4] = blocklengths[5] = data_struct_dist->entries;
 
   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 → Codes/malleability/MAM_Types.h

-#ifndef MALLEABILITY_TYPES_H
-#define MALLEABILITY_TYPES_H
+#ifndef MAM_TYPES_H
+#define MAM_TYPES_H
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <mpi.h>
 #include <fcntl.h>
 #include <sys/stat.h>
-#include "malleabilityStates.h"
+#include "MAM_Constants.h"
 
-#define MALLEABILITY_INIT_DATA_QTY 100
+#define MAM_TYPES_INIT_DATA_QTY 100
 
 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,9 +25,9 @@ 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 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 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);
 void free_malleability_data_struct(malleability_data_t *data_struct);
 
 #endif

Codes/malleability/MAM_Zombies.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <mpi.h>
+#include <signal.h>
+#include "MAM_Zombies.h"
+#include "MAM_DataStructures.h"
+
+#define PIDS_QTY 320
+//TODO Add option to allow the usage of signal USR2 or not.
+//This code asumes ROOT of each group will be the last to be zombified
+//
+
+void MAM_I_zombies_collect(int new_zombies);
+void MAM_I_zombies_split();
+void MAM_I_zombies_suspend();
+int MAM_I_zombies_awake();
+void zombies_handler_usr2() {}
+
+int *pids = NULL;
+int zombies_qty = 0;
+
+
+void MAM_Zombies_service_init() {
+  zombies_qty = 0;
+  pids = malloc(PIDS_QTY * sizeof(int));
+
+  for(int i=0; i<PIDS_QTY; i++) {
+    pids[i] = 0;
+  }
+}
+
+int MAM_Zombies_service_free() {
+  int request_abort = MAM_I_zombies_awake();
+  free(pids);
+  return request_abort;
+}
+
+
+void MAM_Zombies_update() {
+  int myId, numP, new_zombies;
+
+  MPI_Comm_rank(mall->original_comm, &myId);
+  MPI_Comm_size(mall->original_comm, &numP);
+
+  MPI_Allreduce(&mall->zombie, &new_zombies, 1, MPI_INT, MPI_SUM, mall->original_comm);
+  if(new_zombies && new_zombies < numP) {
+    MAM_I_zombies_collect(new_zombies);
+    MAM_I_zombies_split();
+    MAM_I_zombies_suspend();
+    if(myId == MAM_ROOT) zombies_qty += new_zombies;
+  }
+}
+
+void MAM_I_zombies_collect(int new_zombies) {
+  int pid = getpid();
+  int *pids_counts, *pids_displs;
+  int i, count, active;
+  int myId, numP;
+
+  MPI_Comm_rank(mall->original_comm, &myId);
+  MPI_Comm_size(mall->original_comm, &numP);
+  pids_counts = (int *) malloc(numP * sizeof(int));
+  pids_displs = (int *) malloc(numP * sizeof(int));
+
+  #if MAM_DEBUG > 2
+    if(myId == MAM_ROOT){ DEBUG_FUNC("Collecting zombies", mall->myId, mall->numP); } fflush(stdout);
+  #endif
+
+  count = mall->zombie;
+  if(myId == MAM_ROOT) {
+    active = numP - new_zombies;
+    for(i=0; i < active; i++) {
+      pids_counts[i] = 0;
+    }
+    pids_displs[i-1] = -1;
+    for(; i< active+new_zombies; i++) {
+      pids_counts[i] = 1;
+      pids_displs[i] = (pids_displs[i-1] + 1) + zombies_qty;
+    }
+  }
+  MPI_Gatherv(&pid, count, MPI_INT, pids, pids_counts, pids_displs, MPI_INT, MAM_ROOT, mall->original_comm);
+  free(pids_counts);
+  free(pids_displs);
+}
+
+void MAM_I_zombies_split() {
+  int myId, color;
+  MPI_Comm new_original_comm;
+
+  MPI_Comm_rank(mall->original_comm, &myId);
+  color = mall->zombie ? MPI_UNDEFINED : 1;
+  MPI_Comm_split(mall->original_comm, color, myId, &new_original_comm);
+
+  if(mall->original_comm != MPI_COMM_WORLD) MPI_Comm_free(&mall->original_comm);
+  if(new_original_comm != MPI_COMM_NULL) MPI_Comm_set_name(new_original_comm, "MAM_ORIGINAL");
+  mall->original_comm = new_original_comm;
+}
+
+void MAM_I_zombies_suspend() {
+  struct sigaction act;
+  if(!mall->zombie) return;
+
+  sigemptyset(&act.sa_mask);
+  act.sa_flags=0;
+  act.sa_handler=zombies_handler_usr2;
+
+  sigaction(SIGUSR2, &act, NULL);
+
+  sigset_t set;
+  sigprocmask(SIG_SETMASK,NULL,&set);
+
+  sigsuspend(&set);
+}
+
+int MAM_I_zombies_awake() {
+  if(mall->internode_group && zombies_qty) return 1; //Request Abort
+  for(int i=0; i < zombies_qty; i++) { // Despertar a los zombies
+    kill(pids[i], SIGUSR2);
+  }
+  zombies_qty = 0;
+  return 0; //Normal termination
+}

Codes/malleability/MAM_Zombies.h

+#ifndef MAM_ZOMBIES_H
+#define MAM_ZOMBIES_H
+
+void MAM_Zombies_service_init();
+int MAM_Zombies_service_free();
+void MAM_Zombies_update();
+
+#endif

Codes/malleability/distribution_methods/Distributed_CommDist.h

+#ifndef MAM_DISTRIBUTED_COMMDIST_H
+#define MAM_DISTRIBUTED_COMMDIST_H
+
+#include <mpi.h>
+
+void sync_communication(void *send, void **recv, int qty, MPI_Datatype datatype, int numP, int numO, int is_children_group, MPI_Comm comm);
+
+void async_communication_start(void *send, void **recv, int qty, MPI_Datatype datatype, int numP, int numO, int is_children_group, MPI_Comm comm, MPI_Request **requests, size_t *request_qty, MPI_Win *win);
+int async_communication_check(int is_children_group, MPI_Request *requests, size_t request_qty);
+void async_communication_wait(MPI_Request *requests, size_t request_qty);
+void async_communication_end(MPI_Request *requests, size_t request_qty, MPI_Win *win);
+
+
+void malloc_comm_array(char **array, int qty, int myId, int numP);
+#endif

Codes/malleability/distribution_methods/block_distribution.h

-#ifndef mall_block_distribution
-#define mall_block_distribution
+#ifndef MAM_BLOCK_DISTRIBUTION_H
+#define MAM_BLOCK_DISTRIBUTION_H
 
 #include <stdio.h>
 #include <stdlib.h>

Codes/malleability/malleabilityDataStructures.h

-#ifndef MALLEABILITY_DATA_STRUCTURES_H
-#define MALLEABILITY_DATA_STRUCTURES_H
-
-/*
- * Shows available data structures for inner ussage.
- */
-#include <mpi.h>
-
-/* --- SPAWN STRUCTURES --- */
-struct physical_dist {
-  int num_cpus, num_nodes;
-  char *nodelist;
-  int target_qty, already_created;
-  int dist_type, info_type;
-};
-
-typedef struct {
-  int myId, root, root_parents;
-  int spawn_qty, initial_qty, target_qty;
-  int already_created;
-  int spawn_method, spawn_is_single, spawn_is_async;
-  char *cmd; //Executable name
-  MPI_Info mapping;
-  MPI_Datatype dtype;
-  struct physical_dist dist; // Used to create mapping var
-
-  MPI_Comm comm, returned_comm;
-} Spawn_data;
-
-#endif

Codes/malleability/malleabilityManager.h

-#ifndef MALLEABILITY_MANAGER_H
-#define MALLEABILITY_MANAGER_H
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <mpi.h>
-#include <fcntl.h>
-#include <sys/stat.h>
-#include <mpi.h>
-#include "../IOcodes/results.h"
-#include "../Main/configuration.h"
-#include "../Main/Main_datatypes.h"
-#include "malleabilityStates.h"
-
-int init_malleability(int myId, int numP, int root, MPI_Comm comm, char *name_exec, char *nodelist, int num_cpus, int num_nodes);
-void free_malleability();
-void indicate_ending_malleability(int new_outside_state);
-int malleability_checkpoint();
-void set_benchmark_grp(int grp);
-
-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_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);
-
-void set_benchmark_configuration(configuration *config_file);
-void get_benchmark_configuration(configuration **config_file);
-void set_benchmark_results(results_data *results);
-void get_benchmark_results(results_data **results);
-
-#endif

Codes/malleability/malleabilityStates.h

-#ifndef MALLEABILITY_STATES_H
-#define MALLEABILITY_STATES_H
-
-#include <stdio.h>
-#include <stdlib.h>
-
-//States
-#define MALL_DENIED -1
-enum mall_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 mall_spawn_methods{MALL_SPAWN_BASELINE, MALL_SPAWN_MERGE};
-#define MALL_SPAWN_PTHREAD 2
-#define MALL_SPAWN_SINGLE 3
-
-enum mall_redistribution_methods{MALL_RED_BASELINE, MALL_RED_POINT, MALL_RED_RMA_LOCK, MALL_RED_RMA_LOCKALL};
-#define MALL_RED_THREAD 2
-#define MALL_RED_IBARRIER 3
-
-#define MALLEABILITY_ROOT 0
-
-#define MAL_APP_EXECUTING 0
-#define MAL_APP_ENDED 1
-
-//TODO DEPRECATE
-#define MAL_INT 0
-#define MAL_CHAR 1
-////////////////
-
-#define MALLEABILITY_CHILDREN 1
-#define MALLEABILITY_NOT_CHILDREN 0
-
-#endif