Merge branch 'dev' of https://gitlab.com/iker_martin/malleability_benchmark into dev

Codes/IOcodes/Makefile

-objects := ini.o read_ini.o results.o
-DISTRI_LOC = $(TOP)/malleability/distribution_methods/block_distribution.h
-CC := gcc
-MCC := mpicc
-CFLAGS := -Wall -Wextra
-
-all: $(objects)
-
-ini.o: ini.c ini.h
-	echo $(BUILDDIR)
-	$(CC) $(CFLAGS) -c -o $(BUILDDIR)/$@ $<
-
-read_ini.o: read_ini.c read_ini.h ini.h $(DISTRI_LOC)
-	$(MCC) $(CFLAGS) -c -o $(BUILDDIR)/$@ $<
-
-results.o: results.c results.h
-	$(MCC) $(CFLAGS) -c -o $(BUILDDIR)/$@ $<
-
-#$@ --> Objeto
-#$< --> Source

Codes/IOcodes/read_ini.c

@@ -3,7 +3,7 @@
 #include <string.h>
 #include <mpi.h>
 #include "read_ini.h"
-#include "../malleability/ProcessDist.h"
+#include "../malleability/spawn_methods/ProcessDist.h"
 #include "../malleability/distribution_methods/block_distribution.h"
 #include "ini.h"
 
@@ -79,9 +79,9 @@ static int handler(void* user, const char* section, const char* name,
 	if(pconfig->actual_resize < pconfig->n_resizes) {
   	  char *aux = strdup(value);
           if (strcmp(aux, "spread") == 0) {
-            pconfig->phy_dist[pconfig->actual_resize] = COMM_PHY_SPREAD;
+            pconfig->phy_dist[pconfig->actual_resize] = MALL_DIST_SPREAD;
   	  } else {
-            pconfig->phy_dist[pconfig->actual_resize] = COMM_PHY_COMPACT;
+            pconfig->phy_dist[pconfig->actual_resize] = MALL_DIST_COMPACT;
 	  }
 	  free(aux);
           pconfig->actual_resize = pconfig->actual_resize+1; // Ultimo elemento del grupo
@@ -265,7 +265,6 @@ void print_config_group(configuration *user_config, int grp) {
  * configuracion al otro grupo.
  */
 void send_config_file(configuration *config_file, int root, MPI_Comm intercomm) {
-
   MPI_Datatype config_type, config_type_array, iter_stage_type;
 
   // Obtener un tipo derivado para enviar todos los
@@ -304,10 +303,7 @@ void send_config_file(configuration *config_file, int root, MPI_Comm intercomm)
  * la funcion "free_config".
  */
 void recv_config_file(int root, MPI_Comm intercomm, configuration **config_file_out) {
-
   MPI_Datatype config_type, config_type_array, iter_stage_type;
-
-
   configuration *config_file = malloc(sizeof(configuration) * 1);
 
   // Obtener un tipo derivado para recibir todos los

Codes/Main/Main.c

@@ -112,14 +112,13 @@ int main(int argc, char *argv[]) {
     do {
 
       group->grp = group->grp + 1;
-      if(group->grp != 0) obtain_op_times(0); //Obtener los nuevos valores de tiempo para el computo
       set_benchmark_grp(group->grp);
-      get_malleability_user_comm(&comm);
-      MPI_Comm_size(comm, &(group->numP));
-      MPI_Comm_rank(comm, &(group->myId));
+      if(group->grp != 0) {
+        obtain_op_times(0); //Obtener los nuevos valores de tiempo para el computo
+      }
 
-      if(config_file->n_resizes != group->grp + 1) { 
-        set_malleability_configuration(config_file->sm, config_file->ss, config_file->phy_dist[group->grp+1], -1, config_file->at, -1);
+      if(config_file->n_resizes != group->grp + 1) { //TODO Llevar a otra funcion
+        set_malleability_configuration(config_file->sm, config_file->ss, config_file->phy_dist[group->grp+1], config_file->at, -1);
         set_children_number(config_file->procs[group->grp+1]); // TODO TO BE DEPRECATED
 
         if(group->grp == 0) {
@@ -134,11 +133,15 @@ int main(int argc, char *argv[]) {
       }
 
       res = work();
-      if(res == MAL_ZOMBIE) break;
+      if(res == MALL_ZOMBIE) break;
+
+      get_malleability_user_comm(&comm);
+      MPI_Comm_size(comm, &(group->numP));
+      MPI_Comm_rank(comm, &(group->myId));
 
       print_local_results();
       reset_results_index(results);
-    } while((config_file->n_resizes > group->grp + 1) && (config_file->sm == COMM_SPAWN_MERGE || config_file->sm == COMM_SPAWN_MERGE_PTHREAD));
+    } while(config_file->n_resizes > group->grp + 1 && config_file->sm == MALL_SPAWN_MERGE);
 
     //
     // TERMINA LA EJECUCION ----------------------------------------------------------
@@ -155,7 +158,7 @@ int main(int argc, char *argv[]) {
       MPI_Comm_free(&comm);
     }
 
-    if(group->myId == ROOT && (config_file->sm == COMM_SPAWN_MERGE || config_file->sm == COMM_SPAWN_MERGE_PTHREAD)) {
+    if(group->myId == ROOT && config_file->sm == MALL_SPAWN_MERGE) {
       MPI_Abort(MPI_COMM_WORLD, -100);
     }
     free_application_data();
@@ -185,7 +188,7 @@ int work() {
   double *matrix = NULL;
 
   maxiter = config_file->iters[group->grp];
-  state = MAL_NOT_STARTED;
+  state = MALL_NOT_STARTED;
 
   res = 0;
   for(iter=group->iter_start; iter < maxiter; iter++) {
@@ -196,7 +199,7 @@ int work() {
     state = malleability_checkpoint();
 
   iter = 0;
-  while(state == MAL_DIST_PENDING || state == MAL_SPAWN_PENDING || state == MAL_SPAWN_SINGLE_PENDING) {
+  while(state == MALL_DIST_PENDING || state == MALL_SPAWN_PENDING || state == MALL_SPAWN_SINGLE_PENDING || state == MALL_SPAWN_ADAPT_POSTPONE) {
     if(iter < config_file->iters[group->grp+1]) {
       iterate(matrix, config_file->granularity, state, iter);
       iter++;
@@ -207,7 +210,7 @@ int work() {
 
   
   if(config_file->n_resizes - 1 == group->grp) res=1;
-  if(state == MAL_ZOMBIE) res=state;
+  if(state == MALL_ZOMBIE) res=state;
   return res;
 }
 
@@ -239,7 +242,7 @@ double iterate(double *matrix, int n, int async_comm, int iter) {
 
   actual_time = MPI_Wtime(); // Guardar tiempos
   // TODO Que diferencie entre ambas en el IO
-  if(async_comm == MAL_DIST_PENDING || async_comm == MAL_SPAWN_PENDING || async_comm == MAL_SPAWN_SINGLE_PENDING) { // Se esta realizando una redistribucion de datos asincrona
+  if(async_comm == MALL_DIST_PENDING || async_comm == MALL_SPAWN_PENDING || async_comm == MALL_SPAWN_SINGLE_PENDING) { // Se esta realizando una redistribucion de datos asincrona
     cnt_async=1;
   }
 
@@ -409,7 +412,7 @@ void obtain_op_times(int compute) {
   for(i=0; i<config_file->n_stages; i++) {
     time+=init_stage(config_file, i, *group, comm, compute);
   }
-  if(!compute) results->wasted_time += time;
+  if(!compute) {results->wasted_time += time;}
 }
 
 /*

Codes/Main/Makefile

-objects1 := computing_func comunication_func linear_reg
-objects2 := process_stage
-objects3 := Main
-
-#Pasar nombre a level -- Los objects/headers/source añadir sufijo
-
-DISTRI_LOC = $(TOP)/malleability/distribution_methods/block_distribution.h
-MALLEABILITY_DEPENDS = $(TOP)/malleability/CommDist.h $(TOP)/malleability/malleabilityStates.h $(TOP)/malleability/malleabilityManager.h
-DEPENDS := Main_datatypes.h
-CC := gcc
-MCC := mpicc
-CFLAGS := -Wall -Wextra
-
-all: $(objects1) $(objects2) $(objects3)
-
-$(objects1): %: %.c %.h $(DEPENDS)
-	$(MCC) $(CFLAGS) -c -o $(BUILDDIR)/$@.o $<
-$(objects2): %: %.c %.h $(objects1).h $(DEPENDS) $(DISTRI_LOC)
-	$(MCC) $(CFLAGS) -c -o $(BUILDDIR)/$@.o $<
-$(objects3): %: %.c $(objects2).h $(DEPENDS) $(TOP)/IOcodes/read_ini.h $(TOP)/IOcodes/results.h $(MALLEABILITY_DEPENDS)
-	$(MCC) $(CFLAGS) -c -o $(BUILDDIR)/$@.o $<
-

Codes/Main/process_stage.c

@@ -267,19 +267,18 @@ void linear_regression_stage(iter_stage_t *stage, group_data group, MPI_Comm com
 */
 
 double init_matrix_pt(group_data group, configuration *config_file, iter_stage_t *stage, MPI_Comm comm, int compute) {
-  double result, t_stage;
+  double result, t_stage, start_time;
 
   result = 0;
   t_stage = stage->t_stage * config_file->factors[group.grp];
   initMatrix(&(stage->double_array), config_file->granularity);
 
-  double start_time = MPI_Wtime();
-  if(group.myId == ROOT && compute) {
-    result+= process_stage(*config_file, *stage, group, comm);
-  }
-
   if(compute) {
+    start_time = MPI_Wtime();
+    if(group.myId == ROOT) {
+      result+= process_stage(*config_file, *stage, group, comm);
       stage->t_op = (MPI_Wtime() - start_time) / stage->operations; //Tiempo de una operacion
+    }
     MPI_Bcast(&(stage->t_op), 1, MPI_DOUBLE, ROOT, comm);
   }
   stage->operations = t_stage / stage->t_op;
@@ -292,13 +291,12 @@ double init_pi_pt(group_data group, configuration *config_file, iter_stage_t *st
 
   result = 0;
   t_stage = stage->t_stage * config_file->factors[group.grp];	 
+  if(compute) {
     start_time = MPI_Wtime();
-  if(group.myId == ROOT && compute) {
+    if(group.myId == ROOT) {
       result+= process_stage(*config_file, *stage, group, comm);
-  }
-
-  if(compute) {
       stage->t_op = (MPI_Wtime() - start_time) / stage->operations; //Tiempo de una operacion
+    }
     MPI_Bcast(&(stage->t_op), 1, MPI_DOUBLE, ROOT, comm);
   }
   stage->operations = t_stage / stage->t_op;
@@ -360,13 +358,13 @@ double init_comm_allgatherv_pt(group_data group, configuration *config_file, ite
       MPI_Reduce(&time, NULL, 1, MPI_DOUBLE, MPI_MAX, ROOT, comm);
     }
   }
-
   if(stage->counts.counts != NULL)
     freeCounts(&(stage->counts));
   prepare_comm_allgatherv(group.numP, stage->real_bytes, &(stage->counts));
       
   get_block_dist(stage->real_bytes, group.myId, group.numP, &dist_data);
   stage->my_bytes = dist_data.tamBl;
+
   if(stage->array != NULL)
     free(stage->array);
   stage->array = malloc(sizeof(char) * stage->my_bytes);

Codes/Main/process_stage.h

@@ -8,11 +8,12 @@
 
 enum compute_methods{COMP_PI, COMP_MATRIX, COMP_POINT, COMP_BCAST, COMP_ALLGATHER, COMP_REDUCE, COMP_ALLREDUCE};
 
-//FIXME Refactor el void
 double init_stage(configuration *config_file, int stage_i, group_data group, MPI_Comm comm, int compute);
+//double stage_init_all();
 double process_stage(configuration config_file, iter_stage_t stage, group_data group, MPI_Comm comm);
 
 double latency(int myId, int numP, MPI_Comm comm);
 double bandwidth(int myId, int numP, MPI_Comm comm, double latency, int n);
+//FIXME Refactor el void??
 void linear_regression_stage(iter_stage_t *stage, group_data group, MPI_Comm comm);
 #endif

Codes/Makefile

-export TOP := $(dir $(CURDIR)/$(word $(words $(MAKEFILE_LIST)),$(MAKEFILE_LIST)))
-BUILD := build
-EXEC := exec
-
-EXECDIR := $(addprefix $(TOP),$(EXEC))
-export BUILDDIR = $(addprefix $(TOP),$(BUILD))
-SUBDIRS := IOcodes Main malleability
-
-.PHONY: subdirs $(SUBDIRS) build all clean clear
-#
-#
-#
-#
-CC := gcc
-MCC := mpicc
-CFLAGS := -Wall -Wextra
-LIBFLAGS := -lm -lslurm -pthread
-#
-#
-#
-#
-
-all: subdirs exec
-install: 
-	#runTests
-
-exec: subdirs
-	mkdir -p $(EXECDIR) all
-	$(MCC) $(CFLAGS) -o $(EXECDIR)/a.out $(wildcard $(BUILDDIR)/*.o) $(LIBFLAGS)
-
-subdirs: $(SUBDIRS)
-$(SUBDIRS): | $(BUILD)
-	$(MAKE) -C $@
-
-
-# Carpeta en la que almacenar los compilados y los ejecutables
-$(BUILD):
-	mkdir -p $(BUILDDIR)
+CC = gcc
+MCC = mpicc
+C_FLAGS_ALL = -Wfatal-errors -Wall -Wextra -Wpedantic -Wconversion -Wshadow
+C_FLAGS = -Wall
+LD_FLAGS = -lm -lslurm -pthread
+
+.PHONY : clean clear
+
+# Final binary
+BIN = a.out
+# Put all auto generated stuff to this build dir.
+BUILD_DIR = ./build
+
+# List of all directories where source files are located
+SRCDIRS = IOcodes Main malleability malleability/spawn_methods malleability/distribution_methods
+
+# List of all .c source files.
+C_FILES = $(foreach dire, $(SRCDIRS), $(wildcard $(dire)/*.c))
+
+# All .o files go to build dir.
+OBJ = $(C_FILES:%.c=$(BUILD_DIR)/%.o)
+# Gcc will create these .d files containing dependencies.
+DEP = $(OBJ:%.o=%.d)
+
+# Default target named after the binary.
+$(BIN) : $(BUILD_DIR)/$(BIN)
+
+# Actual target of the binary - depends on all .o files.
+$(BUILD_DIR)/$(BIN) : $(OBJ)
+	$(MCC) $(C_FLAGS) $^ -o $@ $(LD_FLAGS)
+
+# Include all .d files
+# .d files are used for knowing the dependencies of each source file
+-include $(DEP)
+
+# Build target for every single object file.
+# The potential dependency on header files is covered
+# by calling `-include $(DEP)`.
+# The -MMD flags additionaly creates a .d file with
+# the same name as the .o file.
+$(BUILD_DIR)/%.o : %.c
+	mkdir -p $(@D)
+	$(MCC) $(C_FLAGS) -MMD -c $< -o $@
 
 clean:
-	-rm $(BUILDDIR)/*.o
+	-rm $(BUILD_DIR)/$(BIN) $(OBJ) $(DEP)
 clear:
 	-rm -rf $(BUILDDIR)
-	-rm -rf $(EXECDIR)
+
+install: 
 

Codes/compila.sh

-
-mpicc -Wall Main/Main.c Main/computing_func.c Main/comunication_func.c Main/linear_reg.c Main/process_stage.c IOcodes/results.c IOcodes/read_ini.c IOcodes/ini.c malleability/malleabilityManager.c malleability/malleabilityTypes.c malleability/malleabilityZombies.c malleability/ProcessDist.c malleability/CommDist.c malleability/distribution_methods/block_distribution.c -pthread -lslurm -lm
-
-if [ $# -gt 0 ]
-then
-  if [ $1 = "-e" ]
-  then
-    echo "Creado ejecutable para ejecuciones"
-    cp a.out bench.out
-  fi
-fi

Codes/malleability/Makefile

-dir_targets := distribution_methods
-objects1 := CommDist
-objects2 := malleabilityTypes ProcessDist
-objects3 := malleabilityZombies
-objects4 := malleabilityManager
-DEPENDS := $(addsuffix .h, malleabilityDataStructures malleabilityStates)
-CC := gcc
-MCC := mpicc
-CFLAGS := -Wall -Wextra
-
-.PHONY: $(dir_targets) subdir
-
-all: subdir $(objects1) $(objects2) $(objects3) $(objects4)
-
-subdir: $(dir_targets)
-$(dir_targets): %:
-	$(MAKE) -C $@
-
-$(objects1): %: %.c %.h $(DEPENDS) $(dir_targets)/block_distribution.h
-	$(MCC) $(CFLAGS) -c -o $(BUILDDIR)/$@.o $<
-
-$(objects2): %: %.c %.h $(DEPENDS)
-	$(MCC) $(CFLAGS) -c -o $(BUILDDIR)/$@.o $<
-
-$(objects3): %: %.c %.h $(DEPENDS) $(TOP)/IOcodes/results.h
-	$(MCC) $(CFLAGS) -c -o $(BUILDDIR)/$@.o $<
-
-$(objects4): %: %.c %.h $(objects1).h $(objects2).h $(objects3).h $(DEPENDS) \
-	                $(TOP)/IOcodes/read_ini.h $(TOP)/IOcodes/results.h $(TOP)/Main/Main_datatypes.h
-	$(MCC) $(CFLAGS) -c -o $(BUILDDIR)/$@.o $<

Codes/malleability/ProcessDist.h

-#ifndef PROCESS_DIST_H
-#define PROCESS_DIST_H
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <mpi.h>
-#include <string.h>
-#include <slurm/slurm.h>
-#include "malleabilityStates.h"
-
-int init_slurm_comm(char *argv, int num_cpus, int num_nodes, char *nodelist, int myId, int numP, int numC, int root, int type_dist, int type_creation, int spawn_is_single, MPI_Comm comm, MPI_Comm *child);
-int check_slurm_comm(int myId, int root, int numP, MPI_Comm *child, MPI_Comm comm, MPI_Comm comm_thread, double *end_real_time);
-
-void malleability_establish_connection(int myId, int root, MPI_Comm *intercomm);
-
-
-void proc_adapt_expand(int *numP, int numC, MPI_Comm intercomm, MPI_Comm *comm, int is_children_group);
-void proc_adapt_shrink(int numC, MPI_Comm *comm, int myId);
-
-#endif

Codes/malleability/distribution_methods/Makefile

-objects1 := block_distribution
-CC := gcc
-MCC := mpicc
-CFLAGS := -Wall -Wextra
-
-all: $(objects1)
-
-$(objects1): %: %.c %.h
-	$(MCC) $(CFLAGS) -c -o $(BUILDDIR)/$@.o $<

Codes/malleability/malleabilityDataStructures.h

@@ -11,7 +11,7 @@ struct physical_dist {
   int num_cpus, num_nodes;
   char *nodelist;
   int target_qty, already_created;
-  int dist_type;
+  int dist_type, info_type;
 };
 
 typedef struct {
@@ -25,10 +25,6 @@ typedef struct {
   struct physical_dist dist; // Used to create mapping var
 
   MPI_Comm comm, returned_comm;
-
-  // To control the spawn state
-  pthread_mutex_t spawn_mutex;
-  pthread_cond_t cond_adapt_rdy;
 } Spawn_data;
 
 #endif

Codes/malleability/malleabilityManager.h

@@ -18,7 +18,7 @@ void indicate_ending_malleability(int new_outside_state);
 int malleability_checkpoint();
 void set_benchmark_grp(int grp);
 
-void set_malleability_configuration(int spawn_type, int spawn_is_single, int spawn_dist, int spawn_threaded, int comm_type, int comm_threaded);
+void set_malleability_configuration(int spawn_method, int spawn_strategies, int spawn_dist, int comm_type, int comm_threaded);
 void set_children_number(int numC); // TODO TO BE DEPRECATED
 void get_malleability_user_comm(MPI_Comm *comm);
 

Codes/malleability/malleabilityStates.h

@@ -5,6 +5,7 @@
 #include <stdlib.h>
 
 //States
+/*
 #define MAL_UNRESERVED -1
 #define MAL_DENIED -2
 #define MAL_ZOMBIE -3
@@ -17,20 +18,27 @@
 #define MAL_DIST_PENDING 6
 #define MAL_DIST_COMPLETED 7
 #define MAL_DIST_ADAPTED 8
+*/
 
-//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_DIST_ADAPTED};
-//enum mall_spawn_methods{MALL_SPAWN_BASELINE, MALL_SPAWN_MERGE};
-//enum mall_spawn_strategies{MALL_SPAWN_SERIAL, MALL_SPAWN_PTHREAD, MALL_SPAWN_MULTIPLE, MALL_SPAWN_SINGLE};
+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
+
+#define MALLEABILITY_ROOT 0
 
 #define MAL_APP_EXECUTING 0
 #define MAL_APP_ENDED 1
 
 // TODO Refactor
+/*
 #define COMM_PHY_SPREAD 1
 #define COMM_PHY_COMPACT 2
+*/
 
+/*
 // SPAWN METHODS
 #define COMM_SPAWN_SERIAL 0
 #define COMM_SPAWN_PTHREAD 1
@@ -43,7 +51,7 @@
 #define COMM_SPAWN_SINGLE 1
 //#define COMM_SPAWN_PTHREAD 2
 //#define COMM_SPAWN_SINGLE 3
-
+*/
 #define MAL_USE_NORMAL 0
 #define MAL_USE_IBARRIER 1
 #define MAL_USE_POINT 2

Codes/malleability/malleabilityTypes.c

@@ -49,13 +49,15 @@ void add_data(void *data, int total_qty, int type, int request_qty, malleability
  * 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 i, rootBcast = MPI_PROC_NULL;
+  int i, is_intercomm, rootBcast = MPI_PROC_NULL;
   MPI_Datatype entries_type, struct_type;
 
-  if(is_children_group) {
-    rootBcast = root;
+
+  MPI_Comm_test_inter(intercomm, &is_intercomm);
+  if(is_intercomm && !is_children_group) {
+    rootBcast = myId == root ? MPI_ROOT : MPI_PROC_NULL;
   } else {
-    if(myId == root) rootBcast = MPI_ROOT;
+    rootBcast = root;
   }
 
   // Mandar primero numero de entradas

Codes/malleability/malleabilityZombies.c

@@ -18,7 +18,7 @@ int offset_pids, *pids = NULL;
 
 void gestor_usr2() {}
 
-void zombies_collect_suspended(MPI_Comm comm, int myId, int numP, int numC, int root, void *results_void, MPI_Comm user_comm) {
+void zombies_collect_suspended(MPI_Comm comm, int myId, int numP, int numC, int root, void *results_void) {
   int pid = getpid();
   int *pids_counts = malloc(numP * sizeof(int));
   int *pids_displs = malloc(numP * sizeof(int));
@@ -41,10 +41,12 @@ void zombies_collect_suspended(MPI_Comm comm, int myId, int numP, int numC, int
   free(pids_counts);
   free(pids_displs);
 
-  if(myId >= numC) {
+  // FIXME No deberia estar aqui
   // Needed to ensure iteration times are collected before suspending these processes
   results_data *results = (results_data *) results_void;
-    compute_results_iter(results, myId, root, user_comm); 
+  compute_results_iter(results, myId, root, comm); 
+
+  if(myId >= numC) {
     zombies_suspend();
   }
 }

Codes/malleability/malleabilityZombies.h

@@ -10,7 +10,7 @@
 //#include <slurm/slurm.h>
 #include <signal.h>
 
-void zombies_collect_suspended(MPI_Comm comm, int myId, int numP, int numC, int root, void *results_void, MPI_Comm user_comm);
+void zombies_collect_suspended(MPI_Comm comm, int myId, int numP, int numC, int root, void *results_void);
 void zombies_service_init();
 void zombies_service_free();
 void zombies_awake();

Codes/malleability/spawn_methods/Baseline.c

@@ -4,6 +4,7 @@
 #include <pthread.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);
@@ -24,10 +25,10 @@ void baseline_establish_connection(int myId, int root, MPI_Comm *parents);
  * nada los hijos.
  */
 int baseline(Spawn_data spawn_data, MPI_Comm *child) { //TODO Tratamiento de errores
-  int numRanks;
-  MPI_Comm_size(spawn_data.comm, &numRanks);
+  MPI_Comm intercomm;
+  MPI_Comm_get_parent(&intercomm);
 
-  if (spawn_data.initial_qty == numRanks) { // Parents path
+  if (intercomm == MPI_COMM_NULL) { // Parents path
     if(spawn_data.spawn_is_single) {  
       baseline_single_spawn(spawn_data, child);
     } else {
@@ -78,11 +79,8 @@ int baseline_single_spawn(Spawn_data spawn_data, MPI_Comm *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);
 
-    if(spawn_data.spawn_is_async) {
-      pthread_mutex_lock(&(spawn_data.spawn_mutex));
-      commState = MALL_SPAWN_SINGLE_COMPLETED; // Indicate other processes to join root to end spawn procedure
-      pthread_mutex_unlock(&(spawn_data.spawn_mutex));
-    }
+    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);
   }