Skip to content

GitLab

Commit 3691698e authored by iker_martin's avatar iker_martin
Browse files

Minor bug fix to recv synch data. Modified headers to set and retrieve data in MaM.

parent d9c396a0
Hide whitespace changes
Inline Side-by-side
Codes/Main/Main.c
View file @ 3691698e
...@@ -98,8 +98,8 @@ int main(int argc, char *argv[]) { ...@@ -98,8 +98,8 @@ int main(int argc, char *argv[]) {
MAM_Set_target_number(config_file->groups[group->grp+1].procs); // TODO TO BE DEPRECATED MAM_Set_target_number(config_file->groups[group->grp+1].procs); // TODO TO BE DEPRECATED
if(group->grp != 0) { if(group->grp != 0) {
malleability_modify_data(&(group->grp), 0, 1, MPI_INT, 1, 1); MAM_Data_modify(&(group->grp), 0, 1, MPI_INT, MAM_DATA_REPLICATED, MAM_DATA_CONSTANT);
malleability_modify_data(&(group->iter_start), 0, 1, MPI_INT, 1, 0); MAM_Data_modify(&(group->iter_start), 0, 1, MPI_INT, MAM_DATA_REPLICATED, MAM_DATA_VARIABLE);
} }
} }
...@@ -473,11 +473,9 @@ void free_application_data() { ...@@ -473,11 +473,9 @@ void free_application_data() {
free(group->async_array); free(group->async_array);
group->async_array = NULL; group->async_array = NULL;
} }
/* MPI_Barrier(MPI_COMM_WORLD); fflush(stdout);
printf("TEST %d\n", group->myId);
MPI_Barrier(MPI_COMM_WORLD); fflush(stdout);*/
MAM_Finalize(); MAM_Finalize();
free_zombie_process(); free_zombie_process();
free(group);
} }
...@@ -489,8 +487,6 @@ void free_zombie_process() { ...@@ -489,8 +487,6 @@ void free_zombie_process() {
free(results); free(results);
free_config(config_file); free_config(config_file);
free(group);
} }
...@@ -529,45 +525,47 @@ void init_originals() { ...@@ -529,45 +525,47 @@ void init_originals() {
size_t i; size_t i;
if(config_file->n_groups > 1) { if(config_file->n_groups > 1) {
malleability_add_data(&(group->grp), 1, MPI_INT, MAM_DATA_REPLICATED, MAM_DATA_CONSTANT); MAM_Data_add(&(group->grp), NULL, 1, MPI_INT, MAM_DATA_REPLICATED, MAM_DATA_CONSTANT);
malleability_add_data(&run_id, 1, MPI_INT, MAM_DATA_REPLICATED, MAM_DATA_CONSTANT); MAM_Data_add(&run_id, NULL, 1, MPI_INT, MAM_DATA_REPLICATED, MAM_DATA_CONSTANT);
malleability_add_data(&(group->iter_start), 1, MPI_INT, MAM_DATA_REPLICATED, MAM_DATA_VARIABLE); MAM_Data_add(&(group->iter_start), NULL, 1, MPI_INT, MAM_DATA_REPLICATED, MAM_DATA_VARIABLE);
if(config_file->sdr) { if(config_file->sdr) {
for(i=0; i<group->sync_data_groups; i++) { for(i=0; i<group->sync_data_groups; i++) {
malleability_add_data(group->sync_array[i], group->sync_qty[i], MPI_CHAR, MAM_DATA_DISTRIBUTED, MAM_DATA_VARIABLE); MAM_Data_add(group->sync_array[i], NULL, group->sync_qty[i], MPI_CHAR, MAM_DATA_DISTRIBUTED, MAM_DATA_VARIABLE);
} }
} }
if(config_file->adr) { if(config_file->adr) {
for(i=0; i<group->async_data_groups; i++) { for(i=0; i<group->async_data_groups; i++) {
malleability_add_data(group->async_array[i], group->async_qty[i], MPI_CHAR, MAM_DATA_DISTRIBUTED, MAM_DATA_CONSTANT); MAM_Data_add(group->async_array[i], NULL, group->async_qty[i], MPI_CHAR, MAM_DATA_DISTRIBUTED, MAM_DATA_CONSTANT);
} }
} }
} }
} }
void init_targets() { void init_targets() {
size_t i, entries; size_t i, entries, total_qty;
void *value = NULL; void *value = NULL;
MPI_Datatype type;
malleability_get_data(&value, 0, MAM_DATA_REPLICATED, MAM_DATA_CONSTANT); MAM_Data_get_pointer(&value, 0, &total_qty, &type, MAM_DATA_REPLICATED, MAM_DATA_CONSTANT);
group->grp = *((int *)value); group->grp = *((int *)value);
group->grp = group->grp + 1; group->grp = group->grp + 1;
recv_config_file(ROOT, new_comm, &config_file); recv_config_file(ROOT, new_comm, &config_file);
results = malloc(sizeof(results_data)); results = malloc(sizeof(results_data));
init_results_data(results, config_file->n_resizes, config_file->n_stages, config_file->groups[group->grp].iters); init_results_data(results, config_file->n_resizes, config_file->n_stages, config_file->groups[group->grp].iters);
results_comm(results, ROOT, config_file->n_resizes, new_comm); results_comm(results, ROOT, config_file->n_resizes, new_comm);
malleability_get_data(&value, 1, MAM_DATA_REPLICATED, MAM_DATA_CONSTANT); MAM_Data_get_pointer(&value, 1, &total_qty, &type, MAM_DATA_REPLICATED, MAM_DATA_CONSTANT);
run_id = *((int *)value); run_id = *((int *)value);
if(config_file->adr) { if(config_file->adr) {
malleability_get_entries(&entries, 0, 1); MAM_Data_get_entries(MAM_DATA_DISTRIBUTED, MAM_DATA_CONSTANT, &entries);
group->async_qty = (int *) malloc(entries * sizeof(int)); group->async_qty = (int *) malloc(entries * sizeof(int));
group->async_array = (char **) malloc(entries * sizeof(char *)); group->async_array = (char **) malloc(entries * sizeof(char *));
for(i=0; i<entries; i++) { for(i=0; i<entries; i++) {
malleability_get_data(&value, i, MAM_DATA_DISTRIBUTED, MAM_DATA_CONSTANT); MAM_Data_get_pointer(&value, i, &total_qty, &type, MAM_DATA_DISTRIBUTED, MAM_DATA_CONSTANT);
group->async_array[i] = (char *)value; group->async_array[i] = (char *)value;
group->async_qty[i] = DR_MAX_SIZE; group->async_qty[i] = DR_MAX_SIZE;
} }
...@@ -577,18 +575,19 @@ void init_targets() { ...@@ -577,18 +575,19 @@ void init_targets() {
} }
void update_targets() { //FIXME Should not be needed after redist -- Declarar antes void update_targets() { //FIXME Should not be needed after redist -- Declarar antes
size_t i, entries; size_t i, entries, total_qty;
void *value = NULL; void *value = NULL;
MPI_Datatype type;
malleability_get_data(&value, 0, MAM_DATA_REPLICATED, MAM_DATA_VARIABLE); MAM_Data_get_pointer(&value, 0, &total_qty, &type, MAM_DATA_REPLICATED, MAM_DATA_VARIABLE);
group->iter_start = *((int *)value); group->iter_start = *((int *)value);
if(config_file->sdr) { if(config_file->sdr) {
malleability_get_entries(&entries, 0, 0); MAM_Data_get_entries(MAM_DATA_DISTRIBUTED, MAM_DATA_VARIABLE, &entries);
group->sync_qty = (int *) malloc(entries * sizeof(int)); group->sync_qty = (int *) malloc(entries * sizeof(int));
group->sync_array = (char **) malloc(entries * sizeof(char *)); group->sync_array = (char **) malloc(entries * sizeof(char *));
for(i=0; i<entries; i++) { for(i=0; i<entries; i++) {
malleability_get_data(&value, i, MAM_DATA_DISTRIBUTED, MAM_DATA_VARIABLE); MAM_Data_get_pointer(&value, i, &total_qty, &type, MAM_DATA_DISTRIBUTED, MAM_DATA_VARIABLE);
group->sync_array[i] = (char *)value; group->sync_array[i] = (char *)value;
group->sync_qty[i] = DR_MAX_SIZE; group->sync_qty[i] = DR_MAX_SIZE;
} }
......
Codes/Main/process_stage.c
View file @ 3691698e
...@@ -304,8 +304,8 @@ double init_comm_ptop_pt(group_data group, configuration *config_file, iter_stag ...@@ -304,8 +304,8 @@ double init_comm_ptop_pt(group_data group, configuration *config_file, iter_stag
free(stage->full_array); free(stage->full_array);
stage->real_bytes = (stage->bytes && !stage->t_capped) ? stage->bytes : config_file->granularity; stage->real_bytes = (stage->bytes && !stage->t_capped) ? stage->bytes : config_file->granularity;
stage->array = calloc(stage->real_bytes * sizeof(char)); stage->array = calloc(stage->real_bytes, sizeof(char));
stage->full_array = calloc(stage->real_bytes * sizeof(char)); stage->full_array = calloc(stage->real_bytes, sizeof(char));
if(compute && !stage->bytes && !stage->t_capped) { if(compute && !stage->bytes && !stage->t_capped) {
time = init_emulation_comm_time(group, config_file, stage, comm); time = init_emulation_comm_time(group, config_file, stage, comm);
...@@ -326,8 +326,8 @@ double init_comm_iptop_pt(group_data group, configuration *config_file, iter_sta ...@@ -326,8 +326,8 @@ double init_comm_iptop_pt(group_data group, configuration *config_file, iter_sta
free(stage->reqs); free(stage->reqs);
stage->real_bytes = (stage->bytes && !stage->t_capped) ? stage->bytes : config_file->granularity; stage->real_bytes = (stage->bytes && !stage->t_capped) ? stage->bytes : config_file->granularity;
stage->array = calloc(stage->real_bytes * sizeof(char)); stage->array = calloc(stage->real_bytes, sizeof(char));
stage->full_array = calloc(stage->real_bytes * sizeof(char)); stage->full_array = calloc(stage->real_bytes, sizeof(char));
if(compute && !stage->bytes) { // t_capped is not considered in this case if(compute && !stage->bytes) { // t_capped is not considered in this case
stage->req_count = 2 * stage->operations; //FIXME Magical number stage->req_count = 2 * stage->operations; //FIXME Magical number
...@@ -354,7 +354,7 @@ double init_comm_bcast_pt(group_data group, configuration *config_file, iter_sta ...@@ -354,7 +354,7 @@ double init_comm_bcast_pt(group_data group, configuration *config_file, iter_sta
free(stage->array); free(stage->array);
stage->real_bytes = (stage->bytes && !stage->t_capped) ? stage->bytes : config_file->granularity; stage->real_bytes = (stage->bytes && !stage->t_capped) ? stage->bytes : config_file->granularity;
stage->array = calloc(stage->real_bytes * sizeof(char)); //FIXME Valgrind indica unitialised stage->array = calloc(stage->real_bytes, sizeof(char)); //FIXME Valgrind indica unitialised
if(compute && !stage->bytes && !stage->t_capped) { if(compute && !stage->bytes && !stage->t_capped) {
time = init_emulation_comm_time(group, config_file, stage, comm); time = init_emulation_comm_time(group, config_file, stage, comm);
......
Codes/malleability/malleabilityManager.c
View file @ 3691698e
...@@ -302,33 +302,25 @@ void MAM_Commit(int *mam_state) { ...@@ -302,33 +302,25 @@ void MAM_Commit(int *mam_state) {
mall_conf->times->malleability_end = MPI_Wtime(); mall_conf->times->malleability_end = MPI_Wtime();
} }
int MAM_Get_Reconf_Info(mam_user_reconf_t *reconf_info) {
if(state != MALL_USER_PENDING) return MALL_DENIED;
*reconf_info = *user_reconf;
return 0;
}
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);
}
/* /*
* Anyade a la estructura concreta de datos elegida * This function adds data to a data structure based on whether the operation is synchronous or asynchronous,
* el nuevo set de datos "data" de un total de "total_qty" elementos. * and whether the data is replicated or distributed. It takes the following parameters:
* * - data: a pointer to the data to be added
* Los datos variables se tienen que anyadir cuando quieran ser mandados, no antes * - index: a pointer to a size_t variable where the index of the added data will be stored
* * - total_qty: the amount of elements in data
* Mas informacion en la funcion "add_data". * - type: the MPI datatype of the data
* * - is_replicated: a flag indicating whether the data is replicated (MAM_DATA_REPLICATED) or not (MAM_DATA_DISTRIBUTED)
* - is_constant: a flag indicating whether the operation is asynchronous (MAM_DATA_CONSTANT) or synchronous (MAM_DATA_VARIABLE)
* Finally, it updates the index with the index of the last added data if index is not NULL.
*/ */
void malleability_add_data(void *data, size_t total_qty, MPI_Datatype type, int is_replicated, int is_constant) { void MAM_Data_add(void *data, size_t *index, size_t total_qty, MPI_Datatype type, int is_replicated, int is_constant) {
size_t total_reqs = 0; size_t total_reqs = 0, returned_index;
if(is_constant) { //Async if(is_constant) { //Async
if(is_replicated) { if(is_replicated) {
total_reqs = 1; total_reqs = 1;
add_data(data, total_qty, type, total_reqs, rep_a_data); add_data(data, total_qty, type, total_reqs, rep_a_data);
returned_index = rep_a_data->entries-1;
} else { } else {
if(mall_conf->red_method == MALL_RED_BASELINE) { if(mall_conf->red_method == MALL_RED_BASELINE) {
total_reqs = 1; total_reqs = 1;
...@@ -337,25 +329,32 @@ void malleability_add_data(void *data, size_t total_qty, MPI_Datatype type, int ...@@ -337,25 +329,32 @@ void malleability_add_data(void *data, size_t total_qty, MPI_Datatype type, int
} }
add_data(data, total_qty, type, total_reqs, dist_a_data); add_data(data, total_qty, type, total_reqs, dist_a_data);
returned_index = dist_a_data->entries-1;
} }
} else { //Sync } else { //Sync
if(is_replicated) { if(is_replicated) {
add_data(data, total_qty, type, total_reqs, rep_s_data); add_data(data, total_qty, type, total_reqs, rep_s_data);
returned_index = rep_s_data->entries-1;
} else { } else {
add_data(data, total_qty, type, total_reqs, dist_s_data); add_data(data, total_qty, type, total_reqs, dist_s_data);
returned_index = dist_s_data->entries-1;
} }
} }
if(index != NULL) *index = returned_index;
} }
/* /*
* Modifica en la estructura concreta de datos elegida en el indice "index" * This function modifies a data entry to a data structure based on whether the operation is synchronous or asynchronous,
* con el set de datos "data" de un total de "total_qty" elementos. * and whether the data is replicated or distributed. It takes the following parameters:
* * - data: a pointer to the data to be added
* Los datos variables se tienen que modificar cuando quieran ser mandados, no antes * - index: a value indicating which entry will be modified
* * - total_qty: the amount of elements in data
* Mas informacion en la funcion "modify_data". * - type: the MPI datatype of the data
* - is_replicated: a flag indicating whether the data is replicated (MAM_DATA_REPLICATED) or not (MAM_DATA_DISTRIBUTED)
* - is_constant: a flag indicating whether the operation is asynchronous (MAM_DATA_CONSTANT) or synchronous (MAM_DATA_VARIABLE)
*/ */
void malleability_modify_data(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) {
size_t total_reqs = 0; size_t total_reqs = 0;
if(is_constant) { if(is_constant) {
...@@ -381,10 +380,13 @@ void malleability_modify_data(void *data, size_t index, size_t total_qty, MPI_Da ...@@ -381,10 +380,13 @@ void malleability_modify_data(void *data, size_t index, size_t total_qty, MPI_Da
} }
/* /*
* Devuelve el numero de entradas para la estructura de descripcion de * This functions returns how many data entries are available for one of the specific data structures.
* datos elegida. * It takes the following parameters:
* - is_replicated: a flag indicating whether the structure is replicated (MAM_DATA_REPLICATED) or not (MAM_DATA_DISTRIBUTED)
* - is_constant: a flag indicating whether the operation is asynchronous (MAM_DATA_CONSTANT) or synchronous (MAM_DATA_VARIABLE)
* - entries: a pointer where the amount of entries will be stored
*/ */
void malleability_get_entries(size_t *entries, int is_replicated, int is_constant){ void MAM_Data_get_entries(int is_replicated, int is_constant, size_t *entries){
if(is_constant) { if(is_constant) {
if(is_replicated) { if(is_replicated) {
...@@ -402,13 +404,16 @@ void malleability_get_entries(size_t *entries, int is_replicated, int is_constan ...@@ -402,13 +404,16 @@ void malleability_get_entries(size_t *entries, int is_replicated, int is_constan
} }
/* /*
* Devuelve el elemento de la lista "index" al usuario. * This function returns a data entry to a data structure based on whether the operation is synchronous or asynchronous,
* La devolución es en el mismo orden que lo han metido los padres * and whether the data is replicated or distributed. It takes the following parameters:
* con la funcion "malleability_add_data()". * - index: a value indicating which entry will be modified
* Es tarea del usuario saber el tipo de esos datos. * - is_replicated: a flag indicating whether the data is replicated (MAM_DATA_REPLICATED) or not (MAM_DATA_DISTRIBUTED)
* TODO Refactor a que sea automatico * - is_constant: a flag indicating whether the operation is asynchronous (MAM_DATA_CONSTANT) or synchronous (MAM_DATA_VARIABLE)
* - data: a pointer where the data will be stored. The user must free it
* - total_qty: the amount of elements in data for all ranks
* - local_qty: the amount of elements in data for this rank
*/ */
void malleability_get_data(void **data, size_t index, int is_replicated, int is_constant) { void MAM_Data_get_pointer(void **data, size_t index, size_t *total_qty, MPI_Datatype *type, int is_replicated, int is_constant) {
malleability_data_t *data_struct; malleability_data_t *data_struct;
if(is_constant) { if(is_constant) {
...@@ -426,8 +431,46 @@ void malleability_get_data(void **data, size_t index, int is_replicated, int is_ ...@@ -426,8 +431,46 @@ void malleability_get_data(void **data, size_t index, int is_replicated, int is_
} }
*data = data_struct->arrays[index]; *data = data_struct->arrays[index];
*total_qty = data_struct->qty[index];
*type = data_struct->types[index];
//get_block_dist(qty, mall->myId, mall->numP, &dist_data); //FIXME Asegurar que numP es correcto
} }
/*
* @brief Returns a structure to perform data redistribution during a reconfiguration.
*
* This function is intended to be called when the state of MaM is MALL_USER_PENDING only.
* It is designed to provide the necessary information for the user to perform data redistribution.
*
* Parameters:
* - mam_user_reconf_t *reconf_info: A pointer to a mam_user_reconf_t structure where the function will store the required information for data redistribution.
*
* Return Value:
* - MAM_OK: If the function successfully retrieves the reconfiguration information.
* - MALL_DENIED: If the function is called when the state of the MaM is not MALL_USER_PENDING.
*/
int MAM_Get_Reconf_Info(mam_user_reconf_t *reconf_info) {
if(state != MALL_USER_PENDING) return MALL_DENIED;
*reconf_info = *user_reconf;
return MAM_OK;
}
/*
* @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 *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);
}
//======================================================|| //======================================================||
//================PRIVATE FUNCTIONS=====================|| //================PRIVATE FUNCTIONS=====================||
...@@ -945,7 +988,8 @@ int end_redistribution() { ...@@ -945,7 +988,8 @@ int end_redistribution() {
for(i=0; i<rep_s_data->entries; i++) { for(i=0; i<rep_s_data->entries; i++) {
MPI_Bcast(rep_s_data->arrays[i], rep_s_data->qty[i], rep_s_data->types[i], mall->root_collectives, mall->intercomm); MPI_Bcast(rep_s_data->arrays[i], rep_s_data->qty[i], rep_s_data->types[i], mall->root_collectives, mall->intercomm);
} }
#if USE_MAL_BARRIERS #if USE_MAL_BARRIERS
MPI_Barrier(mall->intercomm); MPI_Barrier(mall->intercomm);
#endif #endif
......
Codes/malleability/malleabilityManager.h
View file @ 3691698e
...@@ -23,15 +23,10 @@ void MAM_Resume_redistribution(int *mam_state); ...@@ -23,15 +23,10 @@ void MAM_Resume_redistribution(int *mam_state);
int MAM_Get_Reconf_Info(mam_user_reconf_t *reconf_info); 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_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_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_entries(int is_replicated, int is_constant, size_t *entries);
//void MAM_Data_get_pointer(size_t index, int is_replicated, int is_constant, void **data, size_t *total_qty, size_t *local_qty); void MAM_Data_get_pointer(void **data, size_t index, size_t *total_qty, MPI_Datatype *type, int is_replicated, int is_constant);
void malleability_add_data(void *data, size_t total_qty, MPI_Datatype type, int is_replicated, int is_constant);
void malleability_modify_data(void *data, size_t index, size_t total_qty, MPI_Datatype 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 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 *mall_time);
......
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment