First commit

malleability/malleabilityZombies.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <mpi.h>
+#include <signal.h>
+#include "malleabilityZombies.h"
+
+#define PIDS_QTY 320
+
+void zombies_suspend();
+
+int offset_pids, *pids = NULL;
+
+
+void gestor_usr2() {}
+
+void zombies_collect_suspended(MPI_Comm comm, int myId, int numP, int numC, int root) {
+  int pid = getpid();
+  int *pids_counts = malloc(numP * sizeof(int));
+  int *pids_displs = malloc(numP * sizeof(int));
+  int i, count=1;
+
+  if(myId < numC) {
+    count = 0;
+    if(myId == root) {
+      for(i=0; i < numC; i++) {
+	pids_counts[i] = 0;
+      }
+      for(i=numC; i<numP; i++) {
+  	pids_counts[i] = 1;
+	pids_displs[i] = (i + offset_pids) - numC;
+      }
+      offset_pids += numP - numC;
+      }
+  }
+  MPI_Gatherv(&pid, count, MPI_INT, pids, pids_counts, pids_displs, MPI_INT, root, comm);
+  free(pids_counts);
+  free(pids_displs);
+
+  if(myId >= numC) {
+    zombies_suspend();
+  }
+}
+
+void zombies_service_init() {
+  offset_pids = 0;
+  pids = malloc(PIDS_QTY * sizeof(int));
+
+  for(int i=0; i<PIDS_QTY; i++) {
+    pids[i] = 0;
+  }
+}
+
+void zombies_service_free() {
+  free(pids);
+}
+
+void zombies_suspend() {
+  struct sigaction act;
+
+  sigemptyset(&act.sa_mask);
+  act.sa_flags=0;
+  act.sa_handler=gestor_usr2;
+
+  sigaction(SIGUSR2, &act, NULL);
+
+  sigset_t set;
+  sigprocmask(SIG_SETMASK,NULL,&set);
+
+  sigsuspend(&set);
+}
+
+void zombies_awake() {
+  for(int i=0; i < offset_pids; i++) { // Despertar a los zombies
+    kill(pids[i], SIGUSR2);
+  }
+}

malleability/malleabilityZombies.h

+#ifndef MALLEABILITY_ZOMBIES_H
+#define MALLEABILITY_ZOMBIES_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <mpi.h>
+#include <signal.h>
+
+void zombies_collect_suspended(MPI_Comm comm, int myId, int numP, int numC, int root);
+void zombies_service_init();
+void zombies_service_free();
+void zombies_awake();
+
+#endif

malleability/spawn_methods/Baseline.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <mpi.h>
+#include "../malleabilityStates.h"
+#include "Baseline.h"
+#include "Spawn_state.h"
+
+//--------------PRIVATE DECLARATIONS---------------//
+int baseline_spawn(Spawn_data spawn_data, MPI_Comm comm, MPI_Comm *child);
+int single_strat_parents(Spawn_data spawn_data, MPI_Comm *child);
+void single_strat_children(int myId, int root, MPI_Comm *parents);
+
+
+//--------------PUBLIC FUNCTIONS---------------//
+/*
+ * Metodo basico para la creacion de procesos. Crea en total
+ * spawn_data.spawn_qty procesos.
+ */
+int baseline(Spawn_data spawn_data, MPI_Comm *child) { //TODO Tratamiento de errores
+  MPI_Comm intercomm;
+  MPI_Comm_get_parent(&intercomm);
+
+  if (intercomm == MPI_COMM_NULL) { // Parents path
+    if (spawn_data.spawn_is_single) {
+      single_strat_parents(spawn_data, child);
+    } else {
+      baseline_spawn(spawn_data, spawn_data.comm, child);
+    }
+  } else if(spawn_data.spawn_is_single) { // Children path
+    single_strat_children(spawn_data.myId, spawn_data.root, child);
+  }
+  return MALL_SPAWN_COMPLETED;
+}
+
+//--------------PRIVATE FUNCTIONS---------------//
+/*
+ * Crea un grupo de procesos segun la configuracion indicada por la funcion
+ * "processes_dist()".
+ */
+int baseline_spawn(Spawn_data spawn_data, MPI_Comm comm, MPI_Comm *child) {
+
+  int rootBcast = MPI_PROC_NULL;
+  if(spawn_data.myId == spawn_data.root) rootBcast = MPI_ROOT;
+
+  // WORK
+  int spawn_err = MPI_Comm_spawn(spawn_data.cmd, MPI_ARGV_NULL, spawn_data.spawn_qty, spawn_data.mapping, spawn_data.root, comm, child, MPI_ERRCODES_IGNORE); 
+  MPI_Comm_set_name(*child, "MPI_COMM_MALL_RESIZE");
+
+  // END WORK
+
+  if(spawn_err != MPI_SUCCESS) {
+    printf("Error creating new set of %d procs.\n", spawn_data.spawn_qty);
+  }
+  MPI_Bcast(&spawn_data, 1, spawn_data.dtype, rootBcast, *child);
+
+  return spawn_err;
+}
+
+/* 
+ * Si la variable "type" es 1, la creación es con la participación de todo el grupo de padres
+ * Si el valor es diferente, la creación es solo con la participación del proceso root
+ */
+int single_strat_parents(Spawn_data spawn_data, MPI_Comm *child) {
+  int spawn_err;
+  char *port_name;
+  MPI_Comm newintercomm;
+
+  if (spawn_data.myId == spawn_data.root) {
+    spawn_err = baseline_spawn(spawn_data, MPI_COMM_SELF, child);
+
+    port_name = (char *) malloc(MPI_MAX_PORT_NAME * sizeof(char));
+    MPI_Recv(port_name, MPI_MAX_PORT_NAME, MPI_CHAR, spawn_data.root, 130, *child, MPI_STATUS_IGNORE);
+
+    set_spawn_state(MALL_SPAWN_SINGLE_COMPLETED, spawn_data.spawn_is_async); // Indicate other processes to join root to end spawn procedure
+
+  } else {
+    port_name = malloc(1);
+  }
+
+  MPI_Comm_connect(port_name, MPI_INFO_NULL, spawn_data.root, spawn_data.comm, &newintercomm);
+
+  if(spawn_data.myId == spawn_data.root)
+    MPI_Comm_free(child);
+  free(port_name);
+  *child = newintercomm;
+
+  return spawn_err;
+}
+
+/*
+ * Conectar grupo de hijos con grupo de padres
+ * Devuelve un intercomunicador para hablar con los padres
+ *
+ * Solo se utiliza cuando la creación de los procesos ha sido
+ * realizada por un solo proceso padre
+ */
+void single_strat_children(int myId, int root, MPI_Comm *parents) {
+  char *port_name;
+  MPI_Comm newintercomm;
+
+  if(myId == root) {
+    port_name = (char *) malloc(MPI_MAX_PORT_NAME * sizeof(char));
+    MPI_Open_port(MPI_INFO_NULL, port_name);
+    MPI_Send(port_name, MPI_MAX_PORT_NAME, MPI_CHAR, root, 130, *parents);
+  } else {
+    port_name = malloc(1);
+  }
+
+  MPI_Comm_accept(port_name, MPI_INFO_NULL, root, MPI_COMM_WORLD, &newintercomm);
+
+  if(myId == root) {
+    MPI_Close_port(port_name);
+  }
+  free(port_name);
+  MPI_Comm_free(parents);
+  *parents = newintercomm;
+}

malleability/spawn_methods/Baseline.h

+#ifndef MALLEABILITY_SPAWN_BASELINE_H
+#define MALLEABILITY_SPAWN_BASELINE_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <mpi.h>
+#include <string.h>
+#include "../malleabilityDataStructures.h"
+
+int baseline(Spawn_data spawn_data, MPI_Comm *child);
+#endif

malleability/spawn_methods/GenericSpawn.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <mpi.h>
+#include <string.h>
+#include "../malleabilityStates.h"
+#include "ProcessDist.h"
+#include "GenericSpawn.h"
+#include "Baseline.h"
+#include "Merge.h"
+#include "Spawn_state.h"
+
+// This code is a Singleton object -- Only one instance can be used at a given time and
+// no multiple calls to perform diferent resizes can be performed at the same time.
+
+Spawn_data *spawn_data = NULL;
+pthread_t spawn_thread;
+MPI_Comm *returned_comm;
+
+double end_time; //FIXME REFACTOR
+
+//--------------PRIVATE CONFIGURATION DECLARATIONS---------------//
+void set_spawn_configuration(char *cmd, int num_cpus, int num_nodes, char *nodelist, int myId, int root, int initial_qty, int target_qty, int type_dist, int spawn_method, int spawn_strategies, MPI_Comm comm);
+void set_basic_spawn_dtype();
+void deallocate_spawn_data();
+
+//--------------PRIVATE DECLARATIONS---------------//
+void generic_spawn(MPI_Comm *child, int data_stage);
+
+int check_single_state(MPI_Comm comm, int global_state);
+int check_generic_state(MPI_Comm comm, MPI_Comm *child, int local_state, double *real_time);
+
+//--------------PRIVATE THREADS DECLARATIONS---------------//
+int allocate_thread_spawn();
+void* thread_work();
+
+
+//--------------PUBLIC FUNCTIONS---------------//
+
+/*
+ * Se solicita la creacion de un nuevo grupo de "numP" procesos con una distribucion
+ * fisica "type_dist".
+ *
+ * Se puede solicitar en primer plano, encargandose por tanto el proceso que llama a esta funcion,
+ * o en segundo plano, donde un hilo se encarga de configurar esta creacion.
+ *
+ * Si se pide en primer plano, al terminarla es posible llamar a "check_spawn_state()" para crear
+ * los procesos.
+ *
+ * Si se pide en segundo plano, llamar a "check_spawn_state()" comprobara si la configuracion para
+ * crearlos esta lista, y si es asi, los crea.
+ *
+ * Devuelve el estado de el procedimiento. Si no devuelve "MALL_SPAWN_COMPLETED", es necesario llamar a
+ * "check_spawn_state()".
+ */
+int init_spawn(char *argv, int num_cpus, int num_nodes, char *nodelist, int myId, int initial_qty, int target_qty, int root, int type_dist, int spawn_method, int spawn_strategies, MPI_Comm comm, MPI_Comm *child) {
+  int local_state;
+  set_spawn_configuration(argv, num_cpus, num_nodes, nodelist, myId, root, initial_qty, target_qty, type_dist, spawn_method, spawn_strategies, comm);
+
+  if(!spawn_data->spawn_is_async) {
+    generic_spawn(child, MALL_NOT_STARTED);
+    local_state = get_spawn_state(spawn_data->spawn_is_async);
+    if (local_state == MALL_SPAWN_COMPLETED)
+      deallocate_spawn_data();
+
+  } else {
+    local_state = spawn_data->spawn_is_single ? 
+	    MALL_SPAWN_SINGLE_PENDING : MALL_SPAWN_PENDING;
+    local_state = spawn_data->spawn_method == MALL_SPAWN_MERGE && spawn_data->initial_qty > spawn_data->target_qty ?
+	    MALL_SPAWN_ADAPT_POSTPONE : local_state;
+    set_spawn_state(local_state, 0);
+    if((spawn_data->spawn_is_single && myId == root) || !spawn_data->spawn_is_single) {
+      allocate_thread_spawn();
+    }
+  }
+    
+  return local_state;
+}
+
+/*
+ * Comprueba si una configuracion para crear un nuevo grupo de procesos esta lista,
+ * y en caso de que lo este, se devuelve el communicador a estos nuevos procesos.
+ */
+int check_spawn_state(MPI_Comm *child, MPI_Comm comm, double *real_time) { 
+  int local_state;
+  int global_state=MALL_NOT_STARTED;
+
+  if(spawn_data->spawn_is_async) { // Async
+    local_state = get_spawn_state(spawn_data->spawn_is_async);
+
+    if(local_state == MALL_SPAWN_SINGLE_PENDING || local_state == MALL_SPAWN_SINGLE_COMPLETED) { // Single
+      global_state = check_single_state(comm, local_state);
+
+    } else if(local_state == MALL_SPAWN_PENDING || local_state == MALL_SPAWN_COMPLETED || local_state == MALL_SPAWN_ADAPTED) { // Baseline
+      global_state = check_generic_state(comm, child, local_state, real_time);
+
+    } else if(local_state == MALL_SPAWN_ADAPT_POSTPONE) {
+      global_state = local_state;
+      
+    } else {
+      printf("Error Check spawn: Configuracion invalida State = %d\n", local_state);
+      MPI_Abort(MPI_COMM_WORLD, -1);
+      return -10;
+    }
+  } else if(spawn_data->spawn_method == MALL_SPAWN_MERGE){ // Start Merge shrink Sync
+    generic_spawn(child, MALL_DIST_COMPLETED);
+    global_state = get_spawn_state(spawn_data->spawn_is_async);
+  }
+  if(global_state == MALL_SPAWN_COMPLETED || global_state == MALL_SPAWN_ADAPTED)
+    deallocate_spawn_data();
+
+  return global_state;
+}
+
+/*
+ * Elimina la bandera bloqueante MALL_SPAWN_ADAPT_POSTPONE para los hilos 
+ * auxiliares. Esta bandera los bloquea para que el metodo Merge shrink no 
+ * avance hasta que se complete la redistribucion de datos. Por tanto,
+ * al modificar la bandera los hilos pueden continuar.
+ *
+ * Por seguridad se comprueba que no se realice el cambio a la bandera a 
+ * no ser que se cumplan las 3 condiciones.
+ */
+void unset_spawn_postpone_flag(int outside_state) {
+  int local_state = get_spawn_state(spawn_data->spawn_is_async);
+  if(local_state == MALL_SPAWN_ADAPT_POSTPONE && outside_state == MALL_SPAWN_ADAPT_PENDING && spawn_data->spawn_is_async) { 
+    set_spawn_state(MALL_SPAWN_PENDING, MALL_SPAWN_PTHREAD);
+    wakeup();
+  }
+}
+
+/*
+ * Funcion bloqueante de los hijos para asegurar que todas las tareas del paso
+ * de creacion de los hijos se terminan correctamente.
+ *
+ * Ademas los hijos obtienen informacion basica de los padres
+ * para el paso de redistribucion de datos (Numeros de procesos y Id del Root).
+ *
+ */
+void malleability_connect_children(int myId, int numP, int root, MPI_Comm comm, int *numP_parents, int *root_parents, MPI_Comm *parents) {
+  spawn_data = (Spawn_data *) malloc(sizeof(Spawn_data));
+  spawn_data->root = root;
+  spawn_data->myId = myId;
+  spawn_data->spawn_qty = numP;
+  spawn_data->target_qty = numP;
+  spawn_data->comm = comm;
+
+  set_basic_spawn_dtype();
+  MPI_Bcast(spawn_data, 1, spawn_data->dtype, MALLEABILITY_ROOT, *parents);
+
+  switch(spawn_data->spawn_method) {
+    case MALL_SPAWN_BASELINE:
+      baseline(*spawn_data, parents);
+      break;
+    case MALL_SPAWN_MERGE:
+      spawn_data->target_qty += spawn_data->initial_qty;
+      merge(*spawn_data, parents, MALL_NOT_STARTED);
+      break;
+  }
+
+  *root_parents = spawn_data->root_parents;
+  *numP_parents = spawn_data->initial_qty;
+
+  MPI_Type_free(&(spawn_data->dtype));
+  free(spawn_data);
+}
+
+/*
+ * Función para obtener si entre las estrategias elegidas, se utiliza
+ * la estrategia pasada como segundo argumento.
+ *
+ * Devuelve en "result" 1(Verdadero) si utiliza la estrategia, 0(Falso) en caso
+ * contrario.
+ */
+int malleability_spawn_contains_strat(int spawn_strategies, int strategy, int *result) {
+  int value = spawn_strategies % strategy ? 0 : 1;
+  if(result != NULL) *result = value;
+  return value;
+}
+
+//--------------PRIVATE CONFIGURATION FUNCTIONS---------------//
+/*
+ * Agrupa en una sola estructura todos los datos de configuración necesarios
+ * e inicializa las estructuras necesarias.
+ */
+void set_spawn_configuration(char *cmd, int num_cpus, int num_nodes, char *nodelist, int myId, int root, int initial_qty, int target_qty, int type_dist, int spawn_method, int spawn_strategies, MPI_Comm comm) {
+  spawn_data = (Spawn_data *) malloc(sizeof(Spawn_data));
+
+  spawn_data->myId = myId;
+  spawn_data->root = root;
+  spawn_data->root_parents = root;
+  spawn_data->initial_qty = initial_qty;
+  spawn_data->target_qty = target_qty;
+  spawn_data->spawn_method = spawn_method;
+  malleability_spawn_contains_strat(spawn_strategies, MALL_SPAWN_SINGLE, &(spawn_data->spawn_is_single));
+  malleability_spawn_contains_strat(spawn_strategies, MALL_SPAWN_PTHREAD, &(spawn_data->spawn_is_async));
+  spawn_data->comm = comm;
+
+  set_basic_spawn_dtype();
+
+  switch(spawn_data->spawn_method) {
+    case MALL_SPAWN_BASELINE:
+      spawn_data->spawn_qty = spawn_data->target_qty;
+      spawn_data->already_created = 0;
+      break;
+    case MALL_SPAWN_MERGE:
+      spawn_data->spawn_qty = spawn_data->target_qty - spawn_data->initial_qty;
+      spawn_data->already_created = spawn_data->initial_qty;
+      break;
+  }
+
+  if(spawn_data->spawn_is_async) {
+    init_spawn_state();
+  }
+
+  spawn_data->mapping = MPI_INFO_NULL;
+  if(spawn_data->myId == spawn_data->root) {
+    physical_struct_create(target_qty, spawn_data->already_created, num_cpus, num_nodes, nodelist, type_dist, MALL_DIST_STRING, &(spawn_data->dist));
+
+    //COPY PROGRAM NAME
+    spawn_data->cmd = malloc((strlen(cmd)+1) * sizeof(char));
+    strcpy(spawn_data->cmd, cmd);
+    spawn_data->cmd[strlen(cmd)]='\0';
+
+  } else {
+    spawn_data->cmd = malloc(1 * sizeof(char));
+  }
+}
+
+/*
+ * Crea un tipo derivado para mandar 4 enteros con informacion
+ * basica a los hijos. Son datos necesarios para que terminen
+ * la creacion de procesos.
+ */
+void set_basic_spawn_dtype() {
+  int i, counts = 4;
+  int blocklengths[] = {1, 1, 1, 1};
+  MPI_Aint displs[counts], dir;
+  MPI_Datatype types[counts];
+
+  // Rellenar vector types
+  types[0] = types[1] = types[2] = types[3] = MPI_INT;
+
+  // Rellenar vector displs
+  MPI_Get_address(spawn_data, &dir);
+
+  MPI_Get_address(&(spawn_data->root_parents), &displs[0]);
+  MPI_Get_address(&(spawn_data->initial_qty), &displs[1]);
+  MPI_Get_address(&(spawn_data->spawn_is_single), &displs[2]);
+  MPI_Get_address(&(spawn_data->spawn_method), &displs[3]);
+
+  for(i=0;i<counts;i++) displs[i] -= dir;
+
+  MPI_Type_create_struct(counts, blocklengths, displs, types, &(spawn_data->dtype));
+  MPI_Type_commit(&(spawn_data->dtype));
+}
+
+/*
+ * Libera una estructura de datos spawn_data
+ * junto a la destrucion de aquellas estructuras que utiliza.
+ */
+void deallocate_spawn_data() {
+  if(spawn_data == NULL) return;
+
+  if(spawn_data->cmd != NULL) {
+    free(spawn_data->cmd);
+  }
+  if(spawn_data->dtype != MPI_DATATYPE_NULL) {
+    MPI_Type_free(&(spawn_data->dtype));
+  }
+  if(spawn_data->mapping != MPI_INFO_NULL) {
+    MPI_Info_free(&(spawn_data->mapping));
+  }
+  if(spawn_data->spawn_is_async) {
+    free_spawn_state();
+  }
+  free(spawn_data); 
+  spawn_data = NULL;
+}
+
+
+//--------------PRIVATE SPAWN CREATION FUNCTIONS---------------//
+
+/*
+ * Funcion generica para la creacion de procesos. Obtiene la configuracion
+ * y segun esta, elige como deberian crearse los procesos.
+ *
+ * Cuando termina, modifica la variable global para indicar este cambio
+ */
+void generic_spawn(MPI_Comm *child, int data_stage) {
+  int local_state, aux_state;
+
+  // WORK
+  if(spawn_data->myId == spawn_data->root && spawn_data->spawn_qty > 0) { //SET MAPPING FOR NEW PROCESSES
+    processes_dist(spawn_data->dist, &(spawn_data->mapping));
+  }
+  switch(spawn_data->spawn_method) {
+    case MALL_SPAWN_BASELINE:
+      local_state = baseline(*spawn_data, child);
+      break;
+    case MALL_SPAWN_MERGE:
+      local_state = merge(*spawn_data, child, data_stage);
+      break;
+  }
+  // END WORK
+  end_time = MPI_Wtime();
+  aux_state = get_spawn_state(spawn_data->spawn_is_async);
+  if(!(aux_state == MALL_SPAWN_PENDING && local_state == MALL_SPAWN_ADAPT_POSTPONE)) {
+    set_spawn_state(local_state, spawn_data->spawn_is_async);
+  }
+}
+
+
+//--------------PRIVATE THREAD FUNCTIONS---------------//
+
+/*
+ * Aloja la memoria para un hilo auxiliar dedicado a la creacion de procesos.
+ * No se puede realizar un "join" sobre el hilo y el mismo libera su memoria
+ * asociado al terminar.
+ */
+int allocate_thread_spawn() {
+  if(pthread_create(&spawn_thread, NULL, thread_work, NULL)) {
+    printf("Error al crear el hilo de SPAWN\n");
+    MPI_Abort(MPI_COMM_WORLD, -1);
+    return -1;
+  }
+  if(pthread_detach(spawn_thread)) {
+    printf("Error when detaching spawning thread\n");
+    MPI_Abort(MPI_COMM_WORLD, -1);
+    return -1;
+  }
+  return 0;
+}
+
+/*
+ * Funcion llamada por un hilo para que este se encarge
+ * de configurar la creacion de un nuevo grupo de procesos.
+ *
+ * Una vez esta lista la configuracion y es posible crear los procesos
+ * se avisa al hilo maestro.
+ */
+void* thread_work() {
+  int local_state;
+  returned_comm = (MPI_Comm *) malloc(sizeof(MPI_Comm));
+ 
+  generic_spawn(returned_comm, MALL_NOT_STARTED);
+
+  local_state = get_spawn_state(MALL_SPAWN_PTHREAD);
+  if(local_state == MALL_SPAWN_ADAPT_POSTPONE || local_state == MALL_SPAWN_PENDING) {
+    // El grupo de procesos se terminara de juntar tras la redistribucion de datos
+
+    local_state = wait_wakeup();
+    generic_spawn(returned_comm, MALL_DIST_COMPLETED);
+  }
+
+  pthread_exit(NULL);
+}
+
+/*
+ * Comprueba si una creacion de procesos asincrona en el
+ * paso "single" ha terminado. 
+ * Si no ha terminado se mantiene el estado 
+ * "MALL_SPAWN_SINGLE_PENDING".
+ *
+ * Si ha terminado se crean los hilos auxiliares para 
+ * los procesos no root y se devuelve el estado
+ * "MALL_SPAWN_PENDING".
+ */
+int check_single_state(MPI_Comm comm, int global_state) {
+  MPI_Bcast(&global_state, 1, MPI_INT, spawn_data->root, comm);
+
+  // Non-root processes join root to finalize the spawn
+  // They also must join if the application has ended its work
+  if(global_state == MALL_SPAWN_SINGLE_COMPLETED) { 
+    global_state = MALL_SPAWN_PENDING;
+    set_spawn_state(global_state, MALL_SPAWN_PTHREAD);
+
+    if(spawn_data->myId != spawn_data->root) {
+      allocate_thread_spawn(spawn_data);
+    }
+  }
+  return global_state;
+}
+
+/*
+ * Comprueba si una creación de procesos asincrona en el
+ * paso "generic" ha terminado.
+ * Si no ha terminado devuelve el estado 
+ * "MALL_SPAWN_PENDING".
+ *
+ * Si ha terminado libera la memoria asociada a spawn_data
+ * y devuelve el estado "MALL_SPAWN_COMPLETED".
+ */
+int check_generic_state(MPI_Comm comm, MPI_Comm *child, int local_state, double *real_time) {
+  int global_state;
+
+  MPI_Allreduce(&local_state, &global_state, 1, MPI_INT, MPI_MIN, comm);
+  if(global_state == MALL_SPAWN_COMPLETED || global_state == MALL_SPAWN_ADAPTED) {
+    set_spawn_state(global_state, MALL_SPAWN_PTHREAD);
+    *child = *returned_comm;
+    deallocate_spawn_data(spawn_data);
+    *real_time=end_time;
+  }
+  return global_state;
+}

malleability/spawn_methods/GenericSpawn.h

+#ifndef MALLEABILITY_GENERIC_SPAWN_H
+#define MALLEABILITY_GENERIC_SPAWN_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <mpi.h>
+#include "../malleabilityDataStructures.h"
+
+int init_spawn(char *argv, int num_cpus, int num_nodes, char *nodelist, int myId, int initial_qty, int target_qty, int root, int type_dist, int spawn_method, int spawn_strategies, MPI_Comm comm, MPI_Comm *child);
+int check_spawn_state(MPI_Comm *child, MPI_Comm comm, double *real_time);
+void malleability_connect_children(int myId, int numP, int root, MPI_Comm comm, int *numP_parents, int *root_parents, MPI_Comm *parents);
+
+
+void unset_spawn_postpone_flag(int outside_state);
+int malleability_spawn_contains_strat(int spawn_strategies, int strategy, int *result);
+
+#endif

malleability/spawn_methods/Merge.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <mpi.h>
+#include "../malleabilityStates.h"
+#include "Merge.h"
+#include "Baseline.h"
+
+//--------------PRIVATE DECLARATIONS---------------//
+void merge_adapt_expand(MPI_Comm *child, int is_children_group);
+void merge_adapt_shrink(int numC, MPI_Comm *child, MPI_Comm comm, int myId);
+
+//--------------PUBLIC FUNCTIONS---------------//
+int merge(Spawn_data spawn_data, MPI_Comm *child, int data_state) {
+  MPI_Comm intercomm;
+  int local_state;
+  int is_children_group = 1;
+
+  if(spawn_data.initial_qty > spawn_data.target_qty) { //Shrink
+    if(data_state == MALL_DIST_COMPLETED) {
+      merge_adapt_shrink(spawn_data.target_qty, child, spawn_data.comm, spawn_data.myId);
+      local_state = MALL_SPAWN_ADAPTED;
+    } else {
+      local_state = MALL_SPAWN_ADAPT_POSTPONE;
+    }
+  } else { //Expand
+    MPI_Comm_get_parent(&intercomm);
+    is_children_group = intercomm == MPI_COMM_NULL ? 0:1;
+
+
+    baseline(spawn_data, child);
+    merge_adapt_expand(child, is_children_group);
+    local_state = MALL_SPAWN_COMPLETED;
+  }
+
+  return local_state;
+}
+
+//--------------PRIVATE MERGE TYPE FUNCTIONS---------------//
+
+/*
+ * Se encarga de que el grupo de procesos resultante se 
+ * encuentren todos en un intra comunicador, uniendo a
+ * padres e hijos en un solo comunicador.
+ *
+ * Se llama antes de la redistribución de datos.
+ *
+ * TODO REFACTOR
+ */
+void merge_adapt_expand(MPI_Comm *child, int is_children_group) {
+  MPI_Comm new_comm = MPI_COMM_NULL;
+
+  MPI_Intercomm_merge(*child, is_children_group, &new_comm); //El que pone 0 va primero
+
+  MPI_Comm_free(child); //POSIBLE ERROR?
+  *child = new_comm;
+
+  //*numP = numC; //TODO REFACTOR Llevar a otra parte -- Hacer solo si MALL_SPAWN_ADAPTED
+  //if(*comm != MPI_COMM_WORLD && *comm != MPI_COMM_NULL) {
+  //  MPI_Comm_free(comm);
+  //}
+}
+
+
+/*
+ * Se encarga de que el grupo de procesos resultante se
+ * eliminen aquellos procesos que ya no son necesarios.
+ * Los procesos eliminados se quedaran como zombies.
+ *
+ * Se llama una vez ha terminado la redistribución de datos.
+ */
+void merge_adapt_shrink(int numC, MPI_Comm *child, MPI_Comm comm, int myId) {
+  int color = MPI_UNDEFINED;
+
+  if(myId < numC) {
+      color = 1;  
+  }
+  MPI_Comm_split(comm, color, myId, child);
+}

malleability/spawn_methods/Merge.h

+#ifndef MALLEABILITY_SPAWN_MERGE_H
+#define MALLEABILITY_SPAWN_MERGE_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <mpi.h>
+#include "../malleabilityDataStructures.h"
+
+int merge(Spawn_data spawn_data, MPI_Comm *child, int data_state);
+
+#endif