Skip to content

GitLab

Commit 306f3cd5 authored by iker_martin's avatar iker_martin
Browse files

WIP - Anadido guardado de tiempos de iteracion - En progreso el guardado de tiempos maleables

parent dd38c0b2
Hide whitespace changes
Inline Side-by-side
Codes/IOcodes/results.c 0 → 100644
View file @ 306f3cd5
#include <stdio.h>
#include <stdlib.h>
#include <mpi.h>
#include "results.h"
void def_results_type(results_data *results, MPI_Datatype *results_type);
//======================================================||
//======================================================||
//================MPI RESULTS FUNCTIONS=================||
//======================================================||
//======================================================||
void send_results(results_data *results, int root, MPI_Comm intercomm) {
MPI_Datatype results_type;
// Obtener un tipo derivado para enviar todos los
// datos escalares con una sola comunicacion
def_results_type(results, &results_type);
MPI_Bcast(results, 1, results_type, root, intercomm);
//Liberar tipos derivados
MPI_Type_free(&results_type);
}
void recv_results(results_data *results, int root, MPI_Comm intercomm) {
MPI_Datatype results_type;
// Obtener un tipo derivado para enviar todos los
// datos escalares con una sola comunicacion
def_results_type(results, &results_type);
MPI_Bcast(results, 1, results_type, root, intercomm);
//Liberar tipos derivados
MPI_Type_free(&results_type);
}
void def_results_type(results_data *results, MPI_Datatype *results_type) {
int i, counts = 3;
int blocklengths[3] = {1, 1, 1};
MPI_Aint displs[counts], dir;
MPI_Datatype types[counts];
// Rellenar vector types
types[0] = types[1] = types[2] = MPI_DOUBLE;
// Rellenar vector displs
MPI_Get_address(results, &dir);
MPI_Get_address(&(results->sync_start), &displs[0]);
MPI_Get_address(&(results->async_start), &displs[1]);
MPI_Get_address(&(results->spawn_time), &displs[2]);
for(i=0;i<counts;i++) displs[i] -= dir;
MPI_Type_create_struct(counts, blocklengths, displs, types, results_type);
MPI_Type_commit(results_type);
}
//======================================================||
//======================================================||
//===============PRINT RESULTS FUNCTIONS================||
//======================================================||
//======================================================||
void print_iter_results(results_data *results, int last_normal_iter_index) {
int i, aux;
printf("Titer: ");
for(i=0; i< results->iter_index; i++) {
printf("%lf ", results->iters_time[i]);
}
printf("\nTtype: ");
for(i=0; i< results->iter_index; i++) {
printf("%d ", results->iters_type[i] == 0);
}
printf("\nTop: ");
for(i=0; i< results->iter_index; i++) {
aux = results->iters_type[i] == 0 ? results->iters_type[last_normal_iter_index] : results->iters_type[i];
printf("%d ", aux);
}
printf("\n");
}
//======================================================||
//======================================================||
//=============INIT/FREE RESULTS FUNCTIONS==============||
//======================================================||
//======================================================||
void init_results_data(results_data **results, int resizes, int iters_size) {
*results = malloc(1 * sizeof(results_data));
(*results)->spawn_time = calloc(resizes, sizeof(double));
(*results)->sync_time = calloc(resizes, sizeof(double));
(*results)->async_time = calloc(resizes, sizeof(double));
(*results)->iters_time = calloc(iters_size * 20, sizeof(double));
(*results)->iters_type = calloc(iters_size * 20, sizeof(int));
(*results)->iter_index = 0;
}
void free_results_data(results_data **results) {
//free((*results)->spawn_time);
//free((*results)->sync_time);
//free((*results)->async_time);
free((*results)->iters_time);
free((*results)->iters_type);
free(*results);
}
Codes/IOcodes/results.h 0 → 100644
View file @ 306f3cd5
#include <stdio.h>
#include <stdlib.h>
#include <mpi.h>
typedef struct {
// Iters data
double *iters_time;
int *iters_type, iter_index;
// Spawn, Sync and Async time
double spawn_start, *spawn_time;
double sync_start, *sync_time;
double async_start, *async_time;
} results_data;
void send_results(results_data *results, int root, MPI_Comm intercomm);
void recv_results(results_data *results, int root, MPI_Comm intercomm);
void print_iter_results(results_data *results, int last_normal_iter_index);
void init_results_data(results_data **results, int resizes, int iters_size);
void free_results_data(results_data **results);
Codes/Main/Main.c
View file @ 306f3cd5
......@@ -2,6 +2,7 @@
#include <stdlib.h>
#include <mpi.h>
#include "../IOcodes/read_ini.h"
#include "../IOcodes/results.h"
#include "../malleability/ProcessDist.h"
#include "../malleability/CommDist.h"
......@@ -19,13 +20,14 @@ void iterate(double *matrix, int n, int async_comm);
void computeMatrix(double *matrix, int n);
void initMatrix(double **matrix, int n);
void print_general_info(int myId, int grp, int numP);
typedef struct {
int myId;
int numP;
int grp;
int iter_start;
MPI_Comm children, parents;
char **argv;
char *sync_array, *async_array;
......@@ -33,13 +35,10 @@ typedef struct {
configuration *config_file;
group_data *group;
// Variables sobre resultados
int *iters_time, *iters_type, iter_index;
results_data *results;
int main(int argc, char *argv[]) {
int numP, myId, i;
int numP, myId;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &numP);
......@@ -58,6 +57,7 @@ int main(int argc, char *argv[]) {
} else { // Si son el primer grupo de procesos, recogen la configuracion inicial
config_file = read_ini_file(argv[1]);
init_results_data(&results, config_file->resizes - 1, config_file->iters[group->grp]);
if(config_file->sdr > 0) {
malloc_comm_array(&(group->sync_array), config_file->sdr , group->myId, group->numP);
}
......@@ -66,38 +66,15 @@ int main(int argc, char *argv[]) {
}
}
iters_time = malloc(config_file->iters[group->grp] * 3 * sizeof(int));
iters_type = malloc(config_file->iters[group->grp] * 3 * sizeof(int));
iter_index = 0;
//if(myId== ROOT) print_config(config_file, group->grp);
work();
/*
if(myId == ROOT) {
if(group->myId == ROOT) { // Print results
print_config_group(config_file, group->grp);
printf("Titer: ");
for(i=0; i<iter_index; i++) {
printf("%d ", iters_time[i]);
}
print_iter_results(results, config_file->iters[group->grp] -1);
}
printf("\nTop: ");
for(i=0; i<iter_index; i++) {
printf("%d ", iters_type[i]);
}
printf("\n");
free(iters_time);
free(iters_type);
}*/
/*
int len;
char *name = malloc(MPI_MAX_PROCESSOR_NAME * sizeof(char));
char *version = malloc(MPI_MAX_LIBRARY_VERSION_STRING * sizeof(char));
MPI_Get_processor_name(name, &len);
MPI_Get_library_version(version, &len);
printf("P%d Nuevo GRUPO %d de %d procs en nodo %s con %s\n", myId, group->grp, numP, name, version);
*/
if(config_file->sdr > 0) {
free(group->sync_array);
......@@ -107,8 +84,7 @@ int main(int argc, char *argv[]) {
}
free(group);
free_config(config_file);
free(iters_time);
free(iters_type);
free_results_data(&results); //FIXME Provoca un error - Entro mal a algun vector??
MPI_Finalize();
return 0;
......@@ -137,7 +113,6 @@ int work() {
for(iter=group->iter_start; iter < maxiter; iter++) {
iterate(matrix, config_file->matrix_tam, state);
}
state = checkpoint(iter, state, &async_comm);
iter = 0;
......@@ -172,7 +147,11 @@ int checkpoint(int iter, int state, MPI_Request **comm_req) {
if(config_file->iters[group->grp] > iter || config_file->resizes == group->grp + 1) {return MAL_COMM_UNINITIALIZED;}
int numS = config_file->procs[group->grp +1];
results->spawn_start = MPI_Wtime();
TC(numS);
results->spawn_time[group->grp + 1] = MPI_Wtime() - results->spawn_start;
state = start_redistribution(numS, comm_req);
} else if(MAL_ASYNC_PENDING) {
......@@ -207,12 +186,17 @@ int start_redistribution(int numS, MPI_Request **comm_req) {
send_config_file(config_file, rootBcast, group->children);
if(config_file->adr > 0) {
results->async_start = MPI_Wtime();
send_async(group->async_array, config_file->adr, group->myId, group->numP, ROOT, group->children, numS, comm_req, config_file->aib);
return MAL_ASYNC_PENDING;
}
if(config_file->sdr > 0) {
results->sync_start = MPI_Wtime();
send_sync(group->sync_array, config_file->sdr, group->myId, group->numP, ROOT, group->children, numS);
}
send_results(results, rootBcast, group->children);
// Desconectar intercomunicador con los hijos
MPI_Comm_disconnect(&(group->children));
......@@ -250,8 +234,10 @@ int check_redistribution(int iter, MPI_Request **comm_req) {
iter_send = iter;
MPI_Bcast(&iter_send, 1, MPI_INT, rootBcast, group->children);
if(config_file->sdr > 0) { // Realizar envio sincrono
results->sync_start = MPI_Wtime();
send_sync(group->sync_array, config_file->sdr, group->myId, group->numP, ROOT, group->children, numS);
}
send_results(results, rootBcast, group->children);
// Desconectar intercomunicador con los hijos
MPI_Comm_disconnect(&(group->children));
......@@ -273,14 +259,20 @@ void Sons_init() {
config_file = recv_config_file(ROOT, group->parents);
int numP_parents = config_file->procs[group->grp -1];
init_results_data(&results, config_file->resizes - 1, config_file->iters[group->grp]);
if(config_file->adr > 0) { // Recibir datos asincronos
recv_async(&(group->async_array), config_file->adr, group->myId, group->numP, ROOT, group->parents, numP_parents, config_file->aib);
MPI_Bcast(&(group->iter_start), 1, MPI_INT, ROOT, group->parents);
results->async_time[group->grp] = MPI_Wtime();
}
if(config_file->sdr > 0) { // Recibir datos sincronos
recv_sync(&(group->sync_array), config_file->sdr, group->myId, group->numP, ROOT, group->parents, numP_parents);
results->sync_time[group->grp] = MPI_Wtime();
}
recv_results(results, ROOT, group->parents);
results->sync_time[group->grp] = MPI_Wtime() - results->sync_start;
results->async_time[group->grp] = MPI_Wtime() - results->async_start;
// Desconectar intercomunicador con los hijos
MPI_Comm_disconnect(&(group->parents));
......@@ -304,24 +296,15 @@ void iterate(double *matrix, int n, int async_comm) {
int i, operations = 0;
start_time = actual_time = MPI_Wtime();
if(async_comm == MAL_ASYNC_PENDING && iter_index > 0) { // Se esta realizando una redistribucion de datos asincrona
MPI_Barrier(MPI_COMM_WORLD); if(group->myId) printf("TEST 0\n"); fflush(stdout); MPI_Barrier(MPI_COMM_WORLD);
operations = iters_type[iter_index - 1];
MPI_Barrier(MPI_COMM_WORLD); if(group->myId) printf("TEST 1\n"); fflush(stdout); MPI_Barrier(MPI_COMM_WORLD);
if(async_comm == MAL_ASYNC_PENDING) { // Se esta realizando una redistribucion de datos asincrona
operations = results->iters_type[config_file->iters[group->grp] - 1];
for (i=0; i<operations; i++) {
//MPI_Barrier(MPI_COMM_WORLD); if(group->myId) printf("TEST 2\n"); fflush(stdout); MPI_Barrier(MPI_COMM_WORLD);
computeMatrix(matrix, n);
//MPI_Barrier(MPI_COMM_WORLD); if(group->myId) printf("TEST 3\n"); fflush(stdout); MPI_Barrier(MPI_COMM_WORLD);
actual_time = MPI_Wtime(); // Guardar tiempos
//MPI_Barrier(MPI_COMM_WORLD); if(group->myId) printf("TEST 4\n"); fflush(stdout); MPI_Barrier(MPI_COMM_WORLD);
}
MPI_Barrier(MPI_COMM_WORLD); if(group->myId) printf("TEST 5\n"); fflush(stdout); MPI_Barrier(MPI_COMM_WORLD);
operations = 0;
MPI_Barrier(MPI_COMM_WORLD); if(group->myId) printf("TEST 6\n"); fflush(stdout); MPI_Barrier(MPI_COMM_WORLD);
} else { // No hay redistribucion de datos actualmente
while (actual_time - start_time < time) {
computeMatrix(matrix, n);
operations++;
......@@ -329,9 +312,9 @@ MPI_Barrier(MPI_COMM_WORLD); if(group->myId) printf("TEST 6\n"); fflush(stdout);
}
}
iters_time[iter_index] = actual_time - start_time;
iters_type[iter_index] = operations;
iter_index = iter_index + 1;
results->iters_time[results->iter_index] = actual_time - start_time;
results->iters_type[results->iter_index] = operations;
results->iter_index = results->iter_index + 1;
}
/*
......@@ -368,3 +351,23 @@ void initMatrix(double **matrix, int n) {
}
}
}
//======================================================||
//======================================================||
//=============???????¿¿¿¿¿¿¿¿ FUNCTIONS================||
//======================================================||
//======================================================||
void print_general_info(int myId, int grp, int numP) {
int len;
char *name = malloc(MPI_MAX_PROCESSOR_NAME * sizeof(char));
char *version = malloc(MPI_MAX_LIBRARY_VERSION_STRING * sizeof(char));
MPI_Get_processor_name(name, &len);
MPI_Get_library_version(version, &len);
printf("P%d Nuevo GRUPO %d de %d procs en nodo %s con %s\n", myId, grp, numP, name, version);
free(name);
free(version);
}
Codes/auxiliar_codes/Recordnodelist.c 0 → 100644
View file @ 306f3cd5
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <slurm/slurm.h>
//--------------PRIVATE DECLARATIONS---------------//
void node_dist(slurm_job_info_t job_record, int type, int total_procs, int **qty, int *used_nodes);
int create_hostfile(char *jobId, char **file_name);
int write_hostfile_node(int ptr, int qty, char *node_name);
void fill_hostfile(slurm_job_info_t job_record, int ptr, int *qty, int used_nodes);
int main(int argc, char *argv[]) {
int jobId, ptr, numP, dist;
char *tmp;
job_info_msg_t *j_info;
slurm_job_info_t last_record;
int used_nodes=0;
int *procs_array;
char *hostfile_name;
if(argc < 3) {
printf("Uso ./a.out numP physical_dist");
exit(-1);
}
numP = atoi(argv[1]);
dist = atoi(argv[2]);
// Get Slurm job info
tmp = getenv("SLURM_JOB_ID");
jobId = atoi(tmp);
slurm_load_job(&j_info, jobId, 1);
last_record = j_info->job_array[j_info->record_count - 1];
// GET NEW DISTRIBUTION
node_dist(last_record, dist, numP, &procs_array, &used_nodes);
// CREATE/UPDATE HOSTFILE
ptr = create_hostfile(tmp, &hostfile_name);
free(hostfile_name);
// SET NEW DISTRIBUTION
fill_hostfile(last_record, ptr, procs_array, used_nodes);
close(ptr);
// Free JOB INFO
slurm_free_job_info_msg(j_info);
return 0;
}
/*
* Obtiene la distribucion fisica del grupo de procesos a crear, devolviendo
* cuantos nodos se van a utilizar y la cantidad de procesos que alojara cada
* nodo.
*
* Se permiten dos tipos de distribuciones fisicas segun el valor de "type":
*
* (1): Orientada a equilibrar el numero de procesos entre
* todos los nodos disponibles.
* (2): Orientada a completar la capacidad de un nodo antes de
* ocupar otro nodo.
*/
void node_dist(slurm_job_info_t job_record, int type, int total_procs, int **qty, int *used_nodes) {
int i, asigCores;
int tamBl, remainder;
int *procs;
procs = calloc(job_record.num_nodes, sizeof(int)); // Numero de procesos por nodo
/* GET NEW DISTRIBUTION */
if(type == 1) { // DIST NODES
*used_nodes = job_record.num_nodes;
tamBl = total_procs / job_record.num_nodes;
remainder = total_procs % job_record.num_nodes;
for(i=0; i<remainder; i++) {
procs[i] = tamBl + 1;
}
for(i=remainder; i<job_record.num_nodes; i++) {
procs[i] = tamBl;
}
} else if (type == 2) { // DIST CPUs
tamBl = job_record.num_cpus / job_record.num_nodes;
asigCores = 0;
i = 0;
*used_nodes = 0;
while(asigCores+tamBl <= total_procs) {
asigCores += tamBl;
procs[i] += tamBl;
i = (i+1) % job_record.num_nodes;
(*used_nodes)++;
}
if(asigCores < total_procs) {
procs[i] += total_procs - asigCores;
(*used_nodes)++;
}
if(*used_nodes > job_record.num_nodes) *used_nodes = job_record.num_nodes;
}
*used_nodes=job_record.num_nodes;
for(i=0; i<*used_nodes; i++) {
if(procs[i] == 0){
procs[i]++;
}
}
*qty = procs;
}
/*
*qty = calloc(*used_nodes, sizeof(int)); // Numero de procesos por nodo
for(i=0; i< *used_nodes; i++) {
(*qty)[i] = procs[i];
}
free(procs);
*/
/*
* Crea un fichero que se utilizara como hostfile
* para un nuevo grupo de procesos.
*
* El nombre es devuelto en el argumento "file_name",
* que tiene que ser un puntero vacio.
*
* Ademas se devuelve un descriptor de fichero para
* modificar el fichero.
*/
int create_hostfile(char *jobId, char **file_name) {
int ptr, err, len;
len = strlen(jobId) + 11;
*file_name = NULL;
*file_name = malloc( len * sizeof(char));
if(*file_name == NULL) return -1; // No ha sido posible alojar la memoria
err = snprintf(*file_name, len, "hostfile.o%s", jobId);
if(err < 0) return -2; // No ha sido posible obtener el nombre de fichero
ptr = open(*file_name, O_WRONLY | O_CREAT | O_TRUNC, 0644);
if(ptr < 0) return -3; // No ha sido posible crear el fichero
return ptr; // Devolver puntero a fichero
}
/*
* Rellena un fichero hostfile indicado por ptr con los nombres
* de los nodos a utilizar indicados por "job_record" y la cantidad
* de procesos que alojara cada nodo indicado por "qty".
*/
void fill_hostfile(slurm_job_info_t job_record, int ptr, int *qty, int used_nodes) {
int i=0;
char *host;
hostlist_t hostlist;
hostlist = slurm_hostlist_create(job_record.nodes);
while ( (host = slurm_hostlist_shift(hostlist)) && i < used_nodes) {
write_hostfile_node(ptr, qty[i], host);
i++;
free(host);
}
slurm_hostlist_destroy(hostlist);
}
/*
* Escribe en el fichero hostfile indicado por ptr una nueva linea.
*
* Esta linea indica el nombre de un nodo y la cantidad de procesos a
* alojar en ese nodo.
*/
int write_hostfile_node(int ptr, int qty, char *node_name) {
int err, len_node, len_int, len;
char *line;
len_node = strlen(node_name);
len_int = snprintf(NULL, 0, "%d", qty);
len = len_node + len_int + 3;
line = malloc(len * sizeof(char));
if(line == NULL) return -1; // No ha sido posible alojar la memoria
err = snprintf(line, len, "%s:%d\n", node_name, qty);
if(err < 0) return -2; // No ha sido posible escribir en el fichero
write(ptr, line, len-1);
free(line);
return 0;
}
Codes/compila.sh
View file @ 306f3cd5
module load mpich-3.4.1-noucx
mpicc -Wall Main/Main.c IOcodes/read_ini.c IOcodes/ini.c malleability/ProcessDist.c malleability/CommDist.c -pthread -lslurm
mpicc -Wall Main/Main.c IOcodes/results.c IOcodes/read_ini.c IOcodes/ini.c malleability/ProcessDist.c malleability/CommDist.c -pthread -lslurm
Codes/error_Ibarrier.txt 0 → 100644
View file @ 306f3cd5
MPICH
P1 of 2 | Padrescounts[2]=25 disp=0
P1 of 2 | Padrescounts[3]=25 disp=25
P0 of 2 | Padrescounts[0]=25 disp=0
P0 of 2 | Padrescounts[1]=25 disp=25
P0 of 4 | Hijoscounts[0]=25 disp=0
P1 of 4 | Hijoscounts[0]=25 disp=0
P2 of 4 | Hijoscounts[1]=25 disp=0
P3 of 4 | Hijoscounts[1]=25 disp=0
Fatal error in PMPI_Wait: Unknown error class, error stack:
PMPI_Wait(204).................: MPI_Wait(request=0x7ffcfa166230, status=0x1) failed
MPIR_Wait(104).................:
MPIDU_Sched_progress_state(955): Invalid communicator
Fatal error in PMPI_Wait: Unknown error class, error stack:
PMPI_Wait(204).................: MPI_Wait(request=0x7ffdd2541a10, status=0x1) failed
MPIR_Wait(104).................:
MPIDU_Sched_progress_state(955): Invalid communicator
Fatal error in PMPI_Wait: Unknown error class, error stack:
PMPI_Wait(204).................: MPI_Wait(request=0x7ffe39910c20, status=0x1) failed
MPIR_Wait(104).................:
MPIDU_Sched_progress_state(955): Invalid communicator
===================================================================================
= BAD TERMINATION OF ONE OF YOUR APPLICATION PROCESSES
= PID 35108 RUNNING AT n01
= EXIT CODE: 139
= CLEANING UP REMAINING PROCESSES
= YOU CAN IGNORE THE BELOW CLEANUP MESSAGES
===================================================================================
END RUN
Codes/malleability/CommDist.c
View file @ 306f3cd5
......@@ -293,7 +293,7 @@ void send_async_arrays(struct Dist_data dist_data, char *array, int rootBcast, i
set_counts(i, numP_child, dist_data, counts.counts);
counts.displs[i] = counts.displs[i-1] + counts.counts[i-1];
}
print_counts(dist_data, counts.counts, counts.displs, numP_child, "Padres");
//print_counts(dist_data, counts.counts, counts.displs, numP_child, "Padres");
/* COMUNICACION DE DATOS */
MPI_Ialltoallv(array, counts.counts, counts.displs, MPI_CHAR, NULL, counts.zero_arr, counts.zero_arr, MPI_CHAR, dist_data.intercomm, comm_req);
......@@ -318,7 +318,7 @@ void recv_async_arrays(struct Dist_data dist_data, char *array, int root, int nu
set_counts(i, numP_parents, dist_data, counts.counts);
counts.displs[i] = counts.displs[i-1] + counts.counts[i-1];
}
print_counts(dist_data, counts.counts, counts.displs, numP_parents, "Hijos");
//print_counts(dist_data, counts.counts, counts.displs, numP_parents, "Hijos");
/* COMUNICACION DE DATOS */
MPI_Ialltoallv(aux, counts.zero_arr, counts.zero_arr, MPI_CHAR, array, counts.counts, counts.displs, MPI_CHAR, dist_data.intercomm, comm_req);
......
Codes/recordMachinefile.sh 0 → 100755
View file @ 306f3cd5
#!/bin/bash
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)
if [ $dist == "node" ]; then
dist=1
elif [ $dist == "cpu" ]; then
dist=2
fi
./auxiliar_codes/Recordnodelist.o $numP $dist
echo $numP
Codes/runBase.sh
View file @ 306f3cd5
#!/bin/bash
#SBATCH -N 2
#SBATCH -N 1
echo "MPICH"
module load mpich-3.4.1-noucx
#module load /home/martini/MODULES/modulefiles/mpich3.4
#export HYDRA_DEBUG=1
#-disable-hostname-propagation -disable-auto-cleanup -pmi-port -hosts n00,n01
mpirun -ppn 1 -np 2 ./a.out test.ini
numP=$(bash recordMachinefile.sh test.ini)
#mpirun -f hostfile.o$SLURM_JOB_ID -np $numP ./a.out test.ini
mpirun -np 2 ./a.out test.ini
rm hostfile.o$SLURM_JOB_ID
echo "END RUN"
Codes/test.ini
View file @ 306f3cd5
[general]
resizes=2 ; Numero de redistribuciones
matrix_tam=2000 ; Tamaño en bytes de la matriz de computo
SDR=20 ; Tamaño en bytes a redistribuir de forma sincrona
ADR=20 ; Tamaño en bytes a redistribuir de forma asincrona
resizes=1 ; Numero de redistribuciones
matrix_tam=1000 ; Tamaño en bytes de la matriz de computo
SDR=100 ; Tamaño en bytes a redistribuir de forma sincrona
ADR=100 ; Tamaño en bytes a redistribuir de forma asincrona 1000000000
AIB=0 ; Indica si las redistribuciones asíncronas se consideran terminadas para los padres
; cuando terminan de enviar (0) o cuando terminan de recibir los valores (1)
time=0.5 ; Tiempo necesario para realizar una iteracion
time=1 ; Tiempo necesario para realizar una iteracion
[resize0] ; Grupo inicial(mpirun) - La aplicación no sigue el valor procs ni physical_dist
iters=5 ; Numero de iteraciones a realizar por este grupo
[resize0] ; Grupo inicial(mpirun)
iters=10 ; Numero de iteraciones a realizar por este grupo
procs=2 ; Cantidad de procesos en el grupo
factor=1 ; Factor de coste
physical_dist=node ; Tipo de redistribución física de los procesos
physical_dist=cpu ; Tipo de redistribución física de los procesos
;end [resize0]
[resize1] ; Grupo de hijos 1
iters=5
iters=20
procs=4
factor=0.5
physical_dist=node
[resize2] ; Grupo de hijos 2
iters=5
procs=8
factor=0.25
physical_dist=node
physical_dist=cpu
Codes/versiones.txt 0 → 100644
View file @ 306f3cd5
MPICH
Config loaded: resizes=3, matrix=2000, sdr=20, adr=20, time=0.500000 || NUMP=1
Resize 0: Iters=5, Procs=1, Factors=1.000000, Phy=1
Resize 1: Iters=5, Procs=2, Factors=1.500000, Phy=2
Resize 2: Iters=5, Procs=8, Factors=0.250000, Phy=1
Config loaded: resizes=3, matrix=2000, sdr=20, adr=20, time=0.500000 || NUMP=2
Resize 0: Iters=5, Procs=1, Factors=1.000000, Phy=1
Resize 1: Iters=5, Procs=2, Factors=1.500000, Phy=2
Resize 2: Iters=5, Procs=8, Factors=0.250000, Phy=1
P0 Nuevo GRUPO 0 de 1 procs en nodo n00 con MPICH Version: 3.4.1
MPICH Release date: Fri Jan 22 14:17:48 CST 2021
MPICH ABI: 13:10:1
MPICH Device: ch3:nemesis
MPICH configure: --prefix=/soft/gnu/mpich-3.4.1-noucx --with-device=ch3:nemesis
MPICH CC: gcc -O2
MPICH CXX: g++ -O2
MPICH F77: gfortran -O2
MPICH FC: gfortran -O2
P0 Nuevo GRUPO 1 de 2 procs en nodo n00 con MPICH Version: 3.4.1
MPICH Release date: Fri Jan 22 14:17:48 CST 2021
MPICH ABI: 13:10:1
MPICH Device: ch3:nemesis
MPICH configure: --prefix=/soft/gnu/mpich-3.4.1-noucx --with-device=ch3:nemesis
MPICH CC: gcc -O2
MPICH CXX: g++ -O2
MPICH F77: gfortran -O2
MPICH FC: gfortran -O2
P1 Nuevo GRUPO 1 de 2 procs en nodo n00 con MPICH Version: 3.4.1
MPICH Release date: Fri Jan 22 14:17:48 CST 2021
MPICH ABI: 13:10:1
MPICH Device: ch3:nemesis
MPICH configure: --prefix=/soft/gnu/mpich-3.4.1-noucx --with-device=ch3:nemesis
MPICH CC: gcc -O2
MPICH CXX: g++ -O2
MPICH F77: gfortran -O2
MPICH FC: gfortran -O2
Config loaded: resizes=3, matrix=2000, sdr=20, adr=20, time=0.500000 || NUMP=8
Resize 0: Iters=5, Procs=1, Factors=1.000000, Phy=1
Resize 1: Iters=5, Procs=2, Factors=1.500000, Phy=2
Resize 2: Iters=5, Procs=8, Factors=0.250000, Phy=1
P2 Nuevo GRUPO 2 de 8 procs en nodo n00 con MPICH Version: 3.4.1
MPICH Release date: Fri Jan 22 14:17:48 CST 2021
MPICH ABI: 13:10:1
MPICH Device: ch3:nemesis
MPICH configure: --prefix=/soft/gnu/mpich-3.4.1-noucx --with-device=ch3:nemesis
MPICH CC: gcc -O2
MPICH CXX: g++ -O2
MPICH F77: gfortran -O2
MPICH FC: gfortran -O2
P4 Nuevo GRUPO 2 de 8 procs en nodo n01 con MPICH Version: 3.4.1
MPICH Release date: Fri Jan 22 14:17:48 CST 2021
MPICH ABI: 13:10:1
MPICH Device: ch3:nemesis
MPICH configure: --prefix=/soft/gnu/mpich-3.4.1-noucx --with-device=ch3:nemesis
MPICH CC: gcc -O2
MPICH CXX: g++ -O2
MPICH F77: gfortran -O2
MPICH FC: gfortran -O2
P6 Nuevo GRUPO 2 de 8 procs en nodo n01 con MPICH Version: 3.4.1
MPICH Release date: Fri Jan 22 14:17:48 CST 2021
MPICH ABI: 13:10:1
MPICH Device: ch3:nemesis
MPICH configure: --prefix=/soft/gnu/mpich-3.4.1-noucx --with-device=ch3:nemesis
MPICH CC: gcc -O2
MPICH CXX: g++ -O2
MPICH F77: gfortran -O2
MPICH FC: gfortran -O2
P7 Nuevo GRUPO 2 de 8 procs en nodo n01 con MPICH Version: 3.4.1
MPICH Release date: Fri Jan 22 14:17:48 CST 2021
MPICH ABI: 13:10:1
MPICH Device: ch3:nemesis
MPICH configure: --prefix=/soft/gnu/mpich-3.4.1-noucx --with-device=ch3:nemesis
MPICH CC: gcc -O2
MPICH CXX: g++ -O2
MPICH F77: gfortran -O2
MPICH FC: gfortran -O2
P5 Nuevo GRUPO 2 de 8 procs en nodo n01 con MPICH Version: 3.4.1
MPICH Release date: Fri Jan 22 14:17:48 CST 2021
MPICH ABI: 13:10:1
MPICH Device: ch3:nemesis
MPICH configure: --prefix=/soft/gnu/mpich-3.4.1-noucx --with-device=ch3:nemesis
MPICH CC: gcc -O2
MPICH CXX: g++ -O2
MPICH F77: gfortran -O2
MPICH FC: gfortran -O2
P1 Nuevo GRUPO 2 de 8 procs en nodo n00 con MPICH Version: 3.4.1
MPICH Release date: Fri Jan 22 14:17:48 CST 2021
MPICH ABI: 13:10:1
MPICH Device: ch3:nemesis
MPICH configure: --prefix=/soft/gnu/mpich-3.4.1-noucx --with-device=ch3:nemesis
MPICH CC: gcc -O2
MPICH CXX: g++ -O2
MPICH F77: gfortran -O2
MPICH FC: gfortran -O2
P3 Nuevo GRUPO 2 de 8 procs en nodo n00 con MPICH Version: 3.4.1
MPICH Release date: Fri Jan 22 14:17:48 CST 2021
MPICH ABI: 13:10:1
MPICH Device: ch3:nemesis
MPICH configure: --prefix=/soft/gnu/mpich-3.4.1-noucx --with-device=ch3:nemesis
MPICH CC: gcc -O2
MPICH CXX: g++ -O2
MPICH F77: gfortran -O2
MPICH FC: gfortran -O2
P0 Nuevo GRUPO 2 de 8 procs en nodo n00 con MPICH Version: 3.4.1
MPICH Release date: Fri Jan 22 14:17:48 CST 2021
MPICH ABI: 13:10:1
MPICH Device: ch3:nemesis
MPICH configure: --prefix=/soft/gnu/mpich-3.4.1-noucx --with-device=ch3:nemesis
MPICH CC: gcc -O2
MPICH CXX: g++ -O2
MPICH F77: gfortran -O2
MPICH FC: gfortran -O2
END RUN
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