runtime - poverty - Tiempo de ejecución global MPI

oxford poverty index

Question

Estoy trabajando en una pequeña aplicación que multiplica una matriz con una Matriz. Funciona sin ningún problema. Estoy buscando para medir el tiempo de ejecución de la aplicación. Puedo encontrar el tiempo individual de ejecución de cada proceso (su inicio y fin) pero necesito el tiempo global.

Este es mi código:

int main(int argc, char **argv){
int rang, procesus;
MPI_Status statut;
double start, end, max_end = 0, min_start = 10000;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rang);
MPI_Comm_size(MPI_COMM_WORLD, &procesus);
MPI_Barrier(MPI_COMM_WORLD);
start = MPI_Wtime();
printf("Starting time of process n. %d %f/n",rang, start);
if(rang==0){
//Master work
}else{
//slaves work
}
MPI_Barrier(MPI_COMM_WORLD);
end = MPI_Wtime();
printf("Ending time of process n.%d %f/n/n/n",rang, end);
MPI_Finalize();
//Out of the Parallelized task
if(min_start > start){
min_start = start;
printf("New minumum starting time %f/n", min_start);
}
if(max_end < end){
max_end = end;
printf("New maximum ending time %f/n", max_end);
}
if(rang == 0){
printf("Start %f/n", min_start);
printf("End %f/n", max_end);
}
return 0;
}

Utilizo los varables min_start y max_end como variables "globales" para tratar de capturar las temperaturas máximas y mínimas de todos los procesos, pero siempre obtengo el tiempo de inicio y finalización del último proceso, el tiempo de finalización es correcto, pero la hora de inicio es incorrecta porque el último proceso fue el primero en comenzar. ¿Qué estoy haciendo mal? ¿Puedo usar una variable realmente global en MPI para todos los procesos, y si puedo, cómo?

Eso es lo que tengo como salida.

Starting time of process n.2. 0.101562
Ending time of process n.2. 0.105469
New minumum starting time 0.101562
New maximum ending time 0.105469
Starting time of process n.3. 0.058594
Ending time of process n.3. 0.062500
New minumum starting time 0.058594
New maximum ending time 0.062500
Starting time of process n. 4. 0.007812
Ending time of process n. 4. 0.011719
New minumum starting time 0.007812
New maximum ending time 0.011719
Starting time of process n.1. 0.148438
Ending time of process n.1. 0.152344
New minumum starting time 0.148438
New maximum ending time 0.152344
Starting time of process n.0. 0.207031
Ending time of process n.0. 0.210938
New minumum starting time 0.207031
New maximum ending time 0.210938
Start 0.207031
End 0.210938

Answer 1

En la mayoría de los casos, a menudo es suficiente simplemente realizar un seguimiento de la hora de inicio y finalización en el nodo maestro y derivar el tiempo de ejecución global solo en el maestro.

Una cosa que vale la pena mencionar es que debe colocar una barrera antes de recopilar la hora de inicio (para asegurarse de que todos los nodos estén listos para continuar) y antes de la hora de finalización (para asegurarse de que todos los nodos estén listos).

double start, end;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Barrier(MPI_COMM_WORLD); /* IMPORTANT */
start = MPI_Wtime();
/* ... do work ... */
MPI_Barrier(MPI_COMM_WORLD); /* IMPORTANT */
end = MPI_Wtime();
MPI_Finalize();
if (rank == 0) { /* use time on master node */
printf("Runtime = %f/n", end-start);
}

Hacer lo mismo en todos los nodos dará casi los mismos resultados con pequeñas desviaciones, según la rapidez con la que cada nodo regrese de la llamada de MPI_Barrier . Este suele ser un valor muy pequeño en relación con la mayoría de las ejecuciones prácticas y se puede descontar.

Tratar de derivar una hora utilizando las horas de inicio / finalización de diferentes nodos no vale la pena, y puede dar sus respuestas incorrectas si MPI_Wtime no utiliza un reloj sincronizado global . Tenga en cuenta que la sincronización de Wtime no es compatible con algunas implementaciones de MPI (verifique MPI_WTIME_IS_GLOBAL ).

Answer 2

MPI_Init() y MPI_Finalize() no marcan el principio y el final de la ejecución en paralelo, solo el principio y el final donde se permiten las llamadas MPI. En MPI, todos sus procesos se ejecutan en paralelo desde el principio hasta el final y no comparten ningún tipo de datos globales.

Puede usar MPI_Reduce() para encontrar el tiempo mínimo de inicio y el tiempo máximo de finalización de los procesos.