Added new recorded time for malleability. It records the time spent in user...

Added new recorded time for malleability. It records the time spent in user redistribution. In addition, bugfixes to ensure comm are correctly disconnected

Codes/IOcodes/results.c

@@ -46,14 +46,14 @@ void results_comm(results_data *results, int root, size_t resizes, MPI_Comm inte
  * En concreto son tres escalares y dos vectores de tamaño "resizes"
  */
 void def_results_type(results_data *results, int resizes, MPI_Datatype *results_type) {
-  int i, counts = 6;
-  int blocklengths[] = {1, 1, 1, 1, 1, 1, 1};
+  int i, counts = 7;
+  int blocklengths[] = {1, 1, 1, 1, 1, 1, 1, 1};
   MPI_Aint displs[counts], dir;
   MPI_Datatype types[counts];
 
   // Rellenar vector types
-  types[0] = types[1] = types[2] = types[3] = types[4] = types[5] = MPI_DOUBLE;
-  blocklengths[2] = blocklengths[3] = blocklengths[4] = blocklengths[5] = resizes;
+  types[0] = types[1] = types[2] = types[3] = types[4] = types[5] = types[6] = MPI_DOUBLE;
+  blocklengths[2] = blocklengths[3] = blocklengths[4] = blocklengths[5] =  blocklengths[6] = resizes;
 
   // Rellenar vector displs
   MPI_Get_address(results, &dir);
@@ -62,8 +62,9 @@ void def_results_type(results_data *results, int resizes, MPI_Datatype *results_
   MPI_Get_address(&(results->wasted_time), &displs[1]);
   MPI_Get_address(results->sync_time, &displs[2]);
   MPI_Get_address(results->async_time, &displs[3]);
-  MPI_Get_address(results->spawn_time, &displs[4]);
-  MPI_Get_address(results->malleability_time, &displs[5]);
+  MPI_Get_address(results->user_time, &displs[4]);
+  MPI_Get_address(results->spawn_time, &displs[5]);
+  MPI_Get_address(results->malleability_time, &displs[6]);
 
   for(i=0;i<counts;i++) displs[i] -= dir;
 
@@ -270,6 +271,11 @@ void print_global_results(results_data results, size_t resizes) {
     printf("%lf ", results.async_time[i]);
   }
 
+  printf("\nT_US: ");
+  for(i=0; i < resizes; i++) {
+    printf("%lf ", results.user_time[i]);
+  }
+
   printf("\nT_Malleability: ");
   for(i=0; i < resizes; i++) {
     printf("%lf ", results.malleability_time[i]);
@@ -296,6 +302,7 @@ void init_results_data(results_data *results, size_t resizes, size_t stages, siz
   results->spawn_time = calloc(resizes, sizeof(double));
   results->sync_time = calloc(resizes, sizeof(double));
   results->async_time = calloc(resizes, sizeof(double));
+  results->user_time = calloc(resizes, sizeof(double));
   results->malleability_time = calloc(resizes, sizeof(double));
   results->wasted_time = 0;
 
@@ -353,6 +360,10 @@ void free_results_data(results_data *results, size_t stages) {
       free(results->async_time);
       results->async_time = NULL;
     }
+    if(results->user_time != NULL) {
+      free(results->user_time);
+      results->user_time = NULL;
+    }
     if(results->malleability_time != NULL) {
       free(results->malleability_time);
       results->malleability_time = NULL;

Codes/IOcodes/results.h

@@ -17,6 +17,7 @@ typedef struct {
   double spawn_start, *spawn_time;
   double sync_end,  *sync_time;
   double async_end, *async_time;
+  double user_end, *user_time;
   double malleability_end, *malleability_time;
   double exec_start, exec_time;
   double wasted_time; // Time spent recalculating iter stages

Codes/Main/Main.c

@@ -82,7 +82,7 @@ int main(int argc, char *argv[]) {
 
       if(group->grp != 0) {
         obtain_op_times(0); //Obtener los nuevos valores de tiempo para el computo
-        MAM_Retrieve_times(&results->spawn_time[group->grp - 1], &results->sync_time[group->grp - 1], &results->async_time[group->grp - 1], &results->malleability_time[group->grp - 1]);
+        MAM_Retrieve_times(&results->spawn_time[group->grp - 1], &results->sync_time[group->grp - 1], &results->async_time[group->grp - 1], &results->user_time[group->grp - 1], &results->malleability_time[group->grp - 1]);
       }
 
       if(config_file->n_groups != group->grp + 1) { //TODO Llevar a otra funcion
@@ -101,11 +101,7 @@ int main(int argc, char *argv[]) {
           MAM_Data_modify(&(group->iter_start), 0, 1, MPI_INT, MAM_DATA_REPLICATED, MAM_DATA_VARIABLE);
         }
       }
-
-    int myId2, numP2;
-    MPI_Comm_size(comm, &numP2);
-    MPI_Comm_rank(comm, &myId2);
-    print_general_info(myId2, group->grp, numP2);
+    
       res = work();
 
       if(res==1) { // Se ha llegado al final de la aplicacion
@@ -521,6 +517,7 @@ int create_out_file(char *nombre, int *ptr, int newstdout) {
 //================ INIT MALLEABILITY ===================||
 //======================================================||
 //======================================================||
+//FIXME TENER EN CUENTA QUE ADR PUEDE SER 0
 
 void init_originals() {
   size_t i;

Codes/malleability/malleabilityManager.c

@@ -162,8 +162,8 @@ int MAM_Finalize() {
   MAM_Free_main_datatype();
   request_abort = MAM_Zombies_service_free();
   free_malleability_times();
-  if(mall->comm != MPI_COMM_WORLD && mall->comm != MPI_COMM_NULL) MPI_Comm_free(&(mall->comm));
-  if(mall->thread_comm != MPI_COMM_WORLD && mall->thread_comm != MPI_COMM_NULL) MPI_Comm_free(&(mall->thread_comm));
+  if(mall->comm != MPI_COMM_WORLD && mall->comm != MPI_COMM_NULL) MPI_Comm_disconnect(&(mall->comm));
+  if(mall->thread_comm != MPI_COMM_WORLD && mall->thread_comm != MPI_COMM_NULL) MPI_Comm_disconnect(&(mall->thread_comm));
   if(mall->intercomm != MPI_COMM_WORLD && mall->intercomm != MPI_COMM_NULL) { MPI_Comm_disconnect(&(mall->intercomm)); } //FIXME Error en OpenMPI + Merge
   if(mall->original_comm != MPI_COMM_WORLD && mall->original_comm != MPI_COMM_NULL) MPI_Comm_free(&(mall->original_comm));
   free(mall);
@@ -265,8 +265,8 @@ void MAM_Commit(int *mam_state) {
   }
 
   // Free unneded communicators
-  if(mall->tmp_comm != MPI_COMM_WORLD && mall->tmp_comm != MPI_COMM_NULL) MPI_Comm_free(&(mall->tmp_comm));
-  if(*(mall->user_comm) != MPI_COMM_WORLD && *(mall->user_comm) != MPI_COMM_NULL) MPI_Comm_free(mall->user_comm);
+  if(mall->tmp_comm != MPI_COMM_WORLD && mall->tmp_comm != MPI_COMM_NULL) MPI_Comm_disconnect(&(mall->tmp_comm));
+  if(*(mall->user_comm) != MPI_COMM_WORLD && *(mall->user_comm) != MPI_COMM_NULL) MPI_Comm_disconnect(mall->user_comm);
 
   // Zombies Treatment
   MAM_Zombies_update();
@@ -469,10 +469,11 @@ int MAM_Get_Reconf_Info(mam_user_reconf_t *reconf_info) {
  *  - 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 *mall_time) {
-  MAM_I_retrieve_times(sp_time, sy_time, asy_time, mall_time);
+void MAM_Retrieve_times(double *sp_time, double *sy_time, double *asy_time, double *user_time, double *mall_time) {
+  MAM_I_retrieve_times(sp_time, sy_time, asy_time, user_time, mall_time);
 }
 
 //======================================================||
@@ -611,6 +612,10 @@ int MAM_St_red_pending(int wait_completed) {
 }
 
 int MAM_St_user_start(int *mam_state) {
+  #if USE_MAL_BARRIERS
+    MPI_Barrier(mall->intercomm);
+  #endif
+  mall_conf->times->user_start = MPI_Wtime(); // Obtener timestamp de cuando termina user redist
   if(MAM_Contains_strat(MAM_SPAWN_STRATEGIES, MAM_STRAT_SPAWN_INTERCOMM, NULL)) {
     MPI_Intercomm_merge(mall->intercomm, MALLEABILITY_NOT_CHILDREN, &mall->tmp_comm); //El que pone 0 va primero
   } else {
@@ -636,6 +641,10 @@ int MAM_St_user_pending(int *mam_state, int wait_completed, void (*user_function
   }
 
   if(state != MALL_USER_PENDING) {
+    #if USE_MAL_BARRIERS
+      MPI_Barrier(mall->intercomm);
+    #endif
+    if(mall_conf->spawn_method == MALL_SPAWN_MERGE) mall_conf->times->user_end = MPI_Wtime(); // Obtener timestamp de cuando termina user redist
     #if USE_MAL_DEBUG
       if(mall->myId == mall->root) DEBUG_FUNC("Ended USER redistribution", mall->myId, mall->numP); fflush(stdout);
     #endif
@@ -778,6 +787,9 @@ void Children_init(void (*user_function)(void *), void *user_args) {
     DEBUG_FUNC("Spawned have completed asynchronous data redistribution step", mall->myId, mall->numP); fflush(stdout); MPI_Barrier(MPI_COMM_WORLD);
   #endif
 
+  #if USE_MAL_BARRIERS
+    MPI_Barrier(mall->intercomm);
+  #endif
   if(MAM_Contains_strat(MAM_SPAWN_STRATEGIES, MAM_STRAT_SPAWN_INTERCOMM, NULL)) {
     MPI_Intercomm_merge(mall->intercomm, MALLEABILITY_CHILDREN, &mall->tmp_comm); //El que pone 0 va primero
   } else {
@@ -789,6 +801,10 @@ void Children_init(void (*user_function)(void *), void *user_args) {
     MAM_I_create_user_struct(MALLEABILITY_CHILDREN);
     user_function(user_args);
   }
+  #if USE_MAL_BARRIERS
+    MPI_Barrier(mall->intercomm);
+  #endif
+  mall_conf->times->user_end = MPI_Wtime(); // Obtener timestamp de cuando termina user redist
 
   comm_data_info(rep_s_data, dist_s_data, MALLEABILITY_CHILDREN);
   if(dist_s_data->entries || rep_s_data->entries) { // Recibir datos sincronos
@@ -987,7 +1003,7 @@ int check_redistribution(int wait_completed) {
     MPI_Barrier(mall->intercomm);
   #endif
   if(mall_conf->spawn_method == MALL_SPAWN_MERGE) mall_conf->times->async_end = MPI_Wtime(); // Merge method only
-  return MALL_USER_PENDING;
+  return MALL_USER_START;
 }
 
 /*
@@ -1081,7 +1097,7 @@ int thread_check(int wait_completed) {
     MPI_Barrier(mall->intercomm);
   #endif
   if(mall_conf->spawn_method == MALL_SPAWN_MERGE) mall_conf->times->async_end = MPI_Wtime(); // Merge method only
-  return MALL_USER_PENDING;
+  return MALL_USER_START;
 }
 
 

Codes/malleability/malleabilityManager.h

@@ -28,6 +28,6 @@ void MAM_Data_modify(void *data, size_t index, size_t total_qty, MPI_Datatype ty
 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);
 
-void MAM_Retrieve_times(double *sp_time, double *sy_time, double *asy_time, double *mall_time);
+void MAM_Retrieve_times(double *sp_time, double *sy_time, double *asy_time, double *user_time, double *mall_time);
 
 #endif

Codes/malleability/malleabilityTimes.c

@@ -25,8 +25,8 @@ void init_malleability_times() {
 
 void reset_malleability_times() {
   malleability_times_t *times = mall_conf->times;
-  times->spawn_start = 0; times->sync_start = 0; times->async_start = 0; times->malleability_start = 0;
-  times->sync_end = 0; times->async_end = 0; times->malleability_end = 0;
+  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;
 }
 
@@ -50,22 +50,23 @@ void malleability_times_broadcast(int root) {
   MPI_Bcast(mall_conf->times, 1, mall_conf->times->times_type, root, mall->intercomm);
 }
 
-void MAM_I_retrieve_times(double *sp_time, double *sy_time, double *asy_time, double *mall_time) {
+void MAM_I_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 def_malleability_times(MPI_Datatype *new_type) {
-  int i, counts = 4;
+  int i, counts = 5;
   int blocklengths[counts];
   MPI_Aint displs[counts], dir;
   MPI_Datatype types[counts];
 
-  blocklengths[0] = blocklengths[1] = blocklengths[2] = blocklengths[3] = 1;
-  types[0] = types[1] =  types[2] = types[3] = MPI_DOUBLE;
+  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
@@ -75,7 +76,8 @@ void def_malleability_times(MPI_Datatype *new_type) {
   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->malleability_start), &displs[3]);
+  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;
 

Codes/malleability/malleabilityTimes.h

@@ -9,6 +9,6 @@ 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 *mall_time);
+void MAM_I_retrieve_times(double *sp_time, double *sy_time, double *asy_time, double *user_time, double *mall_time);
 
 #endif