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

Codes/malleability/distribution_methods/Makefile

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

Codes/malleability/distribution_methods/block_distribution.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <mpi.h>
+#include "block_distribution.h"
+
+void set_interblock_counts(int id, int numP, struct Dist_data data_dist, int *sendcounts);
+void get_util_ids(struct Dist_data dist_data, int numP_other, int **idS);
+
+/*
+ * Prepares a communication from "numP" processes to "numP_other" processes
+ * of "n" elements an returns an struct of counts with 3 arrays to perform the
+ * communications.
+ *
+ * The struct should be freed with freeCounts
+ */
+void prepare_comm_alltoall(int myId, int numP, int numP_other, int n, struct Counts *counts) {
+  int i, *idS;
+  struct Dist_data dist_data;
+
+  get_block_dist(n, myId, numP, &dist_data);
+  mallocCounts(counts, numP_other);
+  get_util_ids(dist_data, numP_other, &idS);
+
+  if(idS[0] == 0) {
+    set_interblock_counts(0, numP_other, dist_data, counts->counts);
+    idS[0]++;
+  }
+  for(i=idS[0]; i<idS[1]; i++) {
+    set_interblock_counts(i, numP_other, dist_data, counts->counts);
+    counts->displs[i] = counts->displs[i-1] + counts->counts[i-1];
+  }
+}
+
+/*
+ * Prepares a communication of "numP" processes of "n" elements an 
+ * returns an struct of counts with 3 arrays to perform the
+ * communications.
+ *
+ * The struct should be freed with freeCounts
+ */
+void prepare_comm_allgatherv(int numP, int n, struct Counts *counts) {
+  int i;
+  struct Dist_data dist_data;
+
+  mallocCounts(counts, numP);
+  get_block_dist(n, 0, numP, &dist_data);
+
+  counts->counts[0] = dist_data.tamBl;
+  for(i=1; i<numP; i++){
+    get_block_dist(n, i, numP, &dist_data);
+    counts->counts[i] = dist_data.tamBl;
+    counts->displs[i] = counts->displs[i-1] + counts->counts[i-1];
+  }
+}
+
+/*
+ * ========================================================================================
+ * ========================================================================================
+ * ================================DISTRIBUTION FUNCTIONS==================================
+ * ========================================================================================
+ * ========================================================================================
+*/
+
+/* 
+ * Obatains for "Id" and "numP", how many
+ * elements per row will have process "Id"
+ * and fills the results in a Dist_data struct
+ */
+void get_block_dist(int qty, int id, int numP, struct Dist_data *dist_data) {
+  int rem;
+
+  dist_data->myId = id;
+  dist_data->numP = numP;
+  dist_data->qty = qty;
+  dist_data->tamBl = qty / numP;
+  rem = qty % numP;
+
+  if(id < rem) { // First subgroup
+    dist_data->ini = id * dist_data->tamBl + id;
+    dist_data->fin = (id+1) * dist_data->tamBl + (id+1);
+  } else { // Second subgroup
+    dist_data->ini = id * dist_data->tamBl + rem;
+    dist_data->fin = (id+1) * dist_data->tamBl + rem;
+  }
+  
+  if(dist_data->fin > qty) {
+    dist_data->fin = qty;
+  }
+  if(dist_data->ini > dist_data->fin) {
+    dist_data->ini = dist_data->fin;
+  }
+
+  dist_data->tamBl = dist_data->fin - dist_data->ini;
+}
+
+
+/*
+ * Obtiene para el Id de un proceso dado, cuantos elementos
+ * enviara o recibira desde el proceso indicado en Dist_data.
+ */
+void set_interblock_counts(int id, int numP, struct Dist_data data_dist, int *sendcounts) {
+  struct Dist_data other;
+  int biggest_ini, smallest_end;
+
+  get_block_dist(data_dist.qty, id, numP, &other);
+
+  // Si el rango de valores no coincide, se pasa al siguiente proceso
+  if(data_dist.ini >= other.fin || data_dist.fin <= other.ini) {
+    return;
+  }
+
+  // Obtiene el proceso con mayor ini entre los dos procesos
+  if(data_dist.ini > other.ini) { 
+    biggest_ini = data_dist.ini;
+  } else {
+    biggest_ini = other.ini;
+  }
+
+  // Obtiene el proceso con menor fin entre los dos procesos
+  if(data_dist.fin < other.fin) {
+    smallest_end = data_dist.fin;
+  } else {
+    smallest_end = other.fin;
+  }
+  sendcounts[id] = smallest_end - biggest_ini; // Numero de elementos a enviar/recibir del proceso Id
+}
+
+
+/*
+ * Obtiene para un proceso de un grupo a que rango procesos de 
+ * otro grupo tiene que enviar o recibir datos.
+ *
+ * Devuelve el primer identificador y el último (Excluido) con el que
+ * comunicarse.
+ */
+void get_util_ids(struct Dist_data dist_data, int numP_other, int **idS) {
+    int idI, idE;
+    int tamOther = dist_data.qty / numP_other;
+    int remOther = dist_data.qty % numP_other;
+    // Indica el punto de corte del grupo de procesos externo que 
+    // divide entre los procesos que tienen 
+    // un tamaño tamOther + 1 y un tamaño tamOther
+    int middle = (tamOther + 1) * remOther;
+
+    // Calcular idI teniendo en cuenta si se comunica con un
+    // proceso con tamano tamOther o tamOther+1
+    if(middle > dist_data.ini) { // First subgroup (tamOther+1)
+      idI = dist_data.ini / (tamOther + 1);
+    } else { // Second subgroup (tamOther)
+      idI = ((dist_data.ini - middle) / tamOther) + remOther;
+    }
+
+    // Calcular idR teniendo en cuenta si se comunica con un
+    // proceso con tamano tamOther o tamOther+1
+    if(middle >= dist_data.fin) { // First subgroup (tamOther +1)
+      idE = dist_data.fin / (tamOther + 1);
+      idE = (dist_data.fin % (tamOther + 1) > 0 && idE+1 <= numP_other) ? idE+1 : idE;
+    } else { // Second subgroup (tamOther)
+      idE = ((dist_data.fin - middle) / tamOther) + remOther;
+      idE = ((dist_data.fin - middle) % tamOther > 0 && idE+1 <= numP_other) ? idE+1 : idE;
+    }
+
+    *idS = malloc(2 * sizeof(int));
+    (*idS)[0] = idI;
+    (*idS)[1] = idE;
+}
+
+/*
+ * ========================================================================================
+ * ========================================================================================
+ * ==============================INIT/FREE/PRINT FUNCTIONS=================================
+ * ========================================================================================
+ * ========================================================================================
+*/
+
+/*
+ * Reserva memoria para los vectores de counts/displs de la funcion
+ * MPI_Alltoallv. Todos los vectores tienen un tamaño de numP, que es la
+ * cantidad de procesos en el otro grupo de procesos.
+ *
+ * El vector counts indica cuantos elementos se comunican desde este proceso
+ * al proceso "i" del otro grupo.
+ *
+ * El vector displs indica los desplazamientos necesarios para cada comunicacion
+ * con el proceso "i" del otro grupo.
+ *
+ * El vector zero_arr se utiliza cuando se quiere indicar un vector incializado
+ * a 0 en todos sus elementos. Sirve para indicar que no hay comunicacion.
+ */
+void mallocCounts(struct Counts *counts, int numP) {
+    counts->counts = calloc(numP, sizeof(int)); 
+    if(counts->counts == NULL) { MPI_Abort(MPI_COMM_WORLD, -2);}
+
+    counts->displs = calloc(numP, sizeof(int));
+    if(counts->displs == NULL) { MPI_Abort(MPI_COMM_WORLD, -2);}
+
+    counts->zero_arr = calloc(numP, sizeof(int));
+    if(counts->zero_arr == NULL) { MPI_Abort(MPI_COMM_WORLD, -2);}
+}
+
+
+/*
+ * Libera la memoria interna de una estructura Counts.
+ *
+ * No libera la memoria de la estructura counts si se ha alojado
+ * de forma dinamica.
+ */
+void freeCounts(struct Counts *counts) {
+    free(counts->counts);
+    free(counts->displs);
+    free(counts->zero_arr);
+    counts->counts = NULL;
+    counts->displs = NULL;
+    counts->zero_arr = NULL;
+}
+
+/*
+ * Muestra la informacion de comunicaciones de un proceso
+ * Si se activa la bandera "include_zero" a verdadero se mostraran para el vector
+ * xcounts los valores a 0.
+ *
+ * En "name" se puede indicar un string con el fin de identificar mejor a que vectores
+ * se refiere la llamada.
+ */
+void print_counts(struct Dist_data data_dist, int *xcounts, int *xdispls, int size, int include_zero, const char* name) {
+  int i;
+
+  for(i=0; i < size; i++) {
+    if(xcounts[i] != 0 || include_zero) {
+      printf("P%d of %d | %scounts[%d]=%d disp=%d\n", data_dist.myId, data_dist.numP, name, i, xcounts[i], xdispls[i]);
+    }
+  }
+}

Codes/malleability/distribution_methods/block_distribution.h

+#ifndef mall_block_distribution
+#define mall_block_distribution
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <mpi.h>
+
+struct Dist_data {
+  int ini; //Primer elemento a enviar
+  int fin; //Ultimo elemento a enviar
+
+  int tamBl; // Total de elementos
+  int qty; // Total number of rows of the full disperse matrix
+
+  int myId;
+  int numP;
+  MPI_Comm intercomm;
+};
+
+struct Counts {
+  int *counts;
+  int *displs;
+  int *zero_arr;
+};
+
+void prepare_comm_alltoall(int myId, int numP, int numP_other, int n, struct Counts *counts);
+void prepare_comm_allgatherv(int numP, int n, struct Counts *counts);
+void get_block_dist(int qty, int id, int numP, struct Dist_data *dist_data);
+
+void mallocCounts(struct Counts *counts, int numP);
+void freeCounts(struct Counts *counts);
+void print_counts(struct Dist_data data_dist, int *xcounts, int *xdispls, int size, int include_zero, const char* name);
+
+#endif

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;
+};
+
+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;
+
+  // To control the spawn state
+  pthread_mutex_t spawn_mutex;
+  pthread_cond_t cond_adapt_rdy;
+} Spawn_data;
+
+#endif

Codes/malleability/malleabilityManager.c

@@ -424,7 +424,7 @@ void Children_init() {
   recv_config_file(mall->root, mall->intercomm, &(mall_conf->config_file));
 
   mall_conf->results = (results_data *) malloc(sizeof(results_data));
-  init_results_data(mall_conf->results, mall_conf->config_file->resizes, RESULTS_INIT_DATA_QTY);
+  init_results_data(mall_conf->results, mall_conf->config_file->n_resizes, RESULTS_INIT_DATA_QTY);
 
   if(dist_a_data->entries || rep_a_data->entries) { // Recibir datos asincronos
     comm_data_info(rep_a_data, dist_a_data, MALLEABILITY_CHILDREN, mall->myId, root_parents, mall->intercomm);
@@ -469,7 +469,7 @@ void Children_init() {
   } 
 
   // Guardar los resultados de esta transmision
-  recv_results(mall_conf->results, mall->root, mall_conf->config_file->resizes, mall->intercomm);
+  recv_results(mall_conf->results, mall->root, mall_conf->config_file->n_resizes, mall->intercomm);
 
   MPI_Comm_disconnect(&(mall->intercomm));
 
@@ -639,7 +639,7 @@ int end_redistribution() {
 //    result = MAL_DIST_ADAPTED;
   }
 
-  send_results(mall_conf->results, rootBcast, mall_conf->config_file->resizes, mall->intercomm);
+  send_results(mall_conf->results, rootBcast, mall_conf->config_file->n_resizes, mall->intercomm);
   result = MAL_DIST_COMPLETED;
 
   MPI_Comm_disconnect(&(mall->intercomm));

Codes/malleability/malleabilityManager.h

+#ifndef MALLEABILITY_MANAGER_H
+#define MALLEABILITY_MANAGER_H
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <mpi.h>
@@ -26,3 +29,5 @@ 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 MAL_UNRESERVED -1
 #define MAL_DENIED -2
@@ -6,18 +12,24 @@
 #define MAL_SPAWN_PENDING 1
 #define MAL_SPAWN_SINGLE_START 2
 #define MAL_SPAWN_SINGLE_PENDING 3
-#define MAL_SPAWN_COMPLETED 4
-#define MAL_DIST_PENDING 5
-#define MAL_DIST_COMPLETED 6
-#define MAL_DIST_ADAPTED 7
-
+#define MAL_SPAWN_ADAPT_POSTPONE 4
+#define MAL_SPAWN_COMPLETED 5
+#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};
 
 #define MAL_APP_EXECUTING 0
 #define MAL_APP_ENDED 1
 
 // TODO Refactor
-#define COMM_PHY_NODES 1
-#define COMM_PHY_CPU 2
+#define COMM_PHY_SPREAD 1
+#define COMM_PHY_COMPACT 2
 
 // SPAWN METHODS
 #define COMM_SPAWN_SERIAL 0
@@ -29,8 +41,8 @@
 //SPAWN STRATEGIES
 #define COMM_SPAWN_MULTIPLE 0
 #define COMM_SPAWN_SINGLE 1
-//#define COMM_SPAWN_SERIAL 0
-//#define COMM_SPAWN_PTHREAD 1
+//#define COMM_SPAWN_PTHREAD 2
+//#define COMM_SPAWN_SINGLE 3
 
 #define MAL_USE_NORMAL 0
 #define MAL_USE_IBARRIER 1
@@ -43,3 +55,5 @@
 
 #define MALLEABILITY_CHILDREN 1
 #define MALLEABILITY_NOT_CHILDREN 0
+
+#endif

Codes/malleability/malleabilityTypes.h

+#ifndef MALLEABILITY_TYPES_H
+#define MALLEABILITY_TYPES_H
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <mpi.h>
@@ -24,3 +27,5 @@ typedef struct {
 void add_data(void *data, int total_qty, int type, int 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);
+
+#endif

Codes/malleability/malleabilityZombies.h

+#ifndef MALLEABILITY_ZOMBIES_H
+#define MALLEABILITY_ZOMBIES_H
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -11,3 +14,5 @@ void zombies_collect_suspended(MPI_Comm comm, int myId, int numP, int numC, int
 void zombies_service_init();
 void zombies_service_free();
 void zombies_awake();
+
+#endif

Codes/recordMachinefile.sh

@@ -5,12 +5,12 @@ dir="/home/martini/malleability_benchmark/Codes/auxiliar_codes"
 aux=$(grep "\[resize0\]" -n $1 | cut -d ":" -f1)
 read -r ini fin <<<$(echo $aux)
 diff=$(( fin - ini ))
-numP=$(head -$fin $1 | tail -$diff | cut -d ';' -f1 | grep procs | cut -d '=' -f2)
-dist=$(head -$fin $1 | tail -$diff | cut -d ';' -f1 | grep physical_dist | cut -d '=' -f2)
+numP=$(head -$fin $1 | tail -$diff | cut -d ';' -f1 | grep Procs | cut -d '=' -f2)
+dist=$(head -$fin $1 | tail -$diff | cut -d ';' -f1 | grep Dist | cut -d '=' -f2)
 
-if [ $dist == "node" ]; then
+if [ $dist == "spread" ]; then
     dist=1
-elif [ $dist == "cpu" ]; then
+elif [ $dist == "compact" ]; then
     dist=2
 fi
 

Codes/runBase.sh

@@ -13,12 +13,12 @@ configFile=$1
 outIndex=$2
 
 echo "MPICH"
-module load mpich-3.4.1-noucx
+#module load mpich-3.4.1-noucx
 #export HYDRA_DEBUG=1
 
 numP=$(bash recordMachinefile.sh $configFile)
 
-#mpirun -print-all-exitcodes -f hostfile.o$SLURM_JOB_ID $dir$codeDir/a.out $configFile $outIndex $nodelist $nodes
+#mpirun -np 4 /home/martini/Instalaciones/valgrind-mpich-3.4.1-noucx/bin/valgrind --leak-check=full --show-leak-kinds=all --log-file=nc.vg.%p $dir$codeDir/a.out $configFile $outIndex $nodelist $nodes
 mpirun -np $numP $dir$codeDir/a.out $configFile $outIndex $nodelist $nodes
 rm hostfile.o$SLURM_JOB_ID
 

Codes/test.ini

 [general]
-resizes=1
-iter_stages=1
-matrix_tam=100000
-comm_tam=47192
+R=0
+S=1
+Granularity=100000
 SDR=0.0
 ADR=0.0
-AIB=0
-CST=1
-CSS=0
-time=0.006
+AT=0
+SM=0
+SS=0
 ; end [general]
 [stage0]
 PT=3
 bytes=0
-t_stage=0.05
+t_stage=0.1
 ;end [stage0]
 [stage1]
-PT=3
+PT=4
 bytes=0
-t_stage=0.05
-;end [stage0]
+t_stage=0.1
+;end [stage1]
+[stage2]
+PT=5
+bytes=0
+t_stage=0.1
+;end [stage2]
+[stage3]
+PT=6
+bytes=0
+t_stage=0.1
+;end [stage3]
 [resize0]
-iters=10
-procs=4
-factor=1
-physical_dist=cpu
+Iters=10
+Procs=40
+FactorS=1
+Dist=compact
 ;end [resize0]
 [resize1]
-iters=10
-procs=8
-factor=0.5
-physical_dist=cpu
+Iters=10
+Procs=8
+FactorS=0.5
+Dist=compact
 ;end [resize1]