Computació d'Altes Prestacions

Facultat de Ciències
Universitat Autònoma de Barcelona

Problemas MPI

1. Describa el efecto de ejecutar los siguientes fragmentos de código, asumiendo que la línea de
comandos es mpirun -np 4 test:

• int V[100];
void main( int argc, char *argv[] )
{
int nproc, rank, i;
MPI_Status s;

MPI_Init( &argc, &argv );

MPI_Comm_size( MPI_COMM_WORLD, &nproc );
MPI_Comm_rank( MPI_COMM_WORLD, &rank );
switch ( rank ){
case 0:
MPI_Recv( V, 25, MPI_INT, 1, 0, MPI_COMM_WORLD, &s );
MPI_Recv( &V[25], 25, MPI_INT, 2, 0, MPI_COMM_WORLD, &s );
MPI_Recv( &V[50], 25, MPI_INT, 3, 0, MPI_COMM_WORLD, &s );
break;
case 1:
for ( i = 0; i < 25; i++ ) V[i] = i + 1;
MPI_Send( V, 25, MPI_INT, 0, 0, MPI_COMM_WORLD );
break;
case 2:
for ( i = 0; i < 25; i++ ) V[i] = (i+1)*2;
MPI_Send( V, 25, MPI_INT, 0, 0, MPI_COMM_WORLD );
break;
case 3:
for ( i = 0; i < 25; i++ ) V[i] = 0 – i - 1;
MPI_Send( V, 25, MPI_INT, 0, 0, MPI_COMM_WORLD );
break;
}
MPI_Finalize();
}
• int Vd[100], Vs[25];
void main( int argc, char *argv[] )
{
int nproc, rank, i;

MPI_Init( &argc, &argv );

MPI_Comm_size( MPI_COMM_WORLD, &nproc );
MPI_Comm_rank( MPI_COMM_WORLD, &rank );
switch ( rank ){
case 0:
for ( i = 0; i < 25; i++ ) Vs[i] = i;
MPI_Gather( Vs, 25, MPI_INT, Vd, 25, MPI_INT, 0, MPI_COMM_WORLD);
break;
case 1:
for ( i = 0; i < 25; i++ ) Vs[i] = i * i + 1;
MPI_Gather( Vs, 25, MPI_INT, Vd, 25, MPI_INT, 0, MPI_COMM_WORLD);
break;
case 2:
for ( i = 0; i < 25; i++ ) Vs[i] = (i+1) * 2;
MPI_Gather( Vs, 25, MPI_INT, Vd, 25, MPI_INT, 0, MPI_COMM_WORLD);
break;
case 3:
for ( i = 0; i < 25; i++ ) Vs[i] = 0-i -1;
MPI_Gather( Vs, 25, MPI_INT, Vd, 25, MPI_INT, 0, MPI_COMM_WORLD);
break;
}
MPI_Finalize();
}

• int Vd[100], Vs[25];

void main( int argc, char *argv[] )
{
int nproc, rank, i; MPI_Request req; MPI_Status s;

MPI_Init( &argc, &argv );

MPI_Comm_size( MPI_COMM_WORLD, &nproc );
MPI_Comm_rank( MPI_COMM_WORLD, &rank );
switch ( rank ){
case 0:
for ( i = 0; i < 25; i++ ) Vs[i] = i;
MPI_Send( Vs, 25, MPI_INT, 1, MPI_COMM_WORLD);
MPI_Send( Vs, 25, MPI_INT, 2, MPI_COMM_WORLD);
MPI_Send( Vs, 25, MPI_INT, 3, MPI_COMM_WORLD);
MPI_Barrier( MPI_COMM_WORLD );
 break;
case 1:
MPI_Irecv( Vs, 25, MPI_INT, 0, MPI_COMM_WORLD, &req);
for ( i = 0; i < 50; i++ ) Vd[i] = -i;
MPI_Wait( req, &s );
for( i = 50; i < 75; i++ ) Vd[i] = Vs[i-50];
MPI_Barrier( MPI_COMM_WORLD );
break;
case 2:
MPI_Irecv( Vs, 25, MPI_INT, 0, MPI_COMM_WORLD, &req);
for ( i = 0; i < 50; i++ ) Vd[i] = (i + 1)*2;
MPI_Wait( req, &s );
for( i = 50; i < 75; i++ ) Vd[i] = Vs[i-50];
MPI_Barrier( MPI_COMM_WORLD );
break;
case 3:
MPI_Irecv( Vs, 25, MPI_INT, 0, MPI_COMM_WORLD, &req);
for ( i = 0; i < 50; i++ ) Vd[i] = (i + 1)*(-2);
MPI_Wait( req, &s );
for( i = 50; i < 75; i++ ) Vd[i] = Vs[i-50];
MPI_Barrier( MPI_COMM_WORLD );
break;
}
MPI_Finalize();
}

2. Paralelice el siguiente código utilizando MPI, de tal forma que cada proceso calcule una parte del
sumatorio:
int main(int argc, char **argv){
int sum = 0;
for(int i=1;i<=1000;i=i+1)
sum = sum + i;
}
El resultado final debe ser calculado por el proceso con rango 0.

3. Escriba un programa donde el proceso con rango 0 lea un dato de tipo entero y donde el resto de
procesos espere dicho dato del proceso anterior y lo reenvíe al siguiente (excepto el último proceso
que no lo envía). [Broadcast en anillo]
Modifique el programa cerrando el anillo, haciendo que cada proceso incremente el valor del entero
recibido y se comunique utilizando comunicación síncrona.

4. Aproximación del número Pi a través de la aproximación de la integral de la función 4/(1+x 2) en el

intervalo [0,1]. Dicha aproximación se realiza calculando y sumando el área de n subintervalos
como: (1/n)*4/(1+x2). El proceso con rango 0 lee del usuario el número de subintervalos y lo envia al
resto de procesos. Luego, cada proceso calcula la suma de las áreas de los subintervalos que le
corresponden (rango/n, rango/n + num_procesos/n) y, finalmente, se hace la suma total de las áreas
 calculadas por cada proceso.

5. Escriba un programa que inicialice dos vectores y lea un escalar. Asuma que la dimensión de los
vectores es múltiplo del número de procesos. Implemente la multiplicación de un escalar por un
vector y el producto punto de vectores. Los vectores deben distribuirse entre todos los procesos y el
escalar debe ser enviado a los mismos. El proceso de rango 0 debe recibir como resultado los
vectores resultantes al aplicar el producto escalar por vector y el resultado del producto punto.

6. Escriba un programa que multiplique de forma distribuida dos matrices A y B NxN (puede asumir
que N es múltiplo del número de procesos o en su caso del número de workers). Pueden plantearse
diferentes alternativas, como por ejemplo un Master/Worker que envía paquetes de una fila y una
columna (o bloques de filas y columnas) a los workers recibiendo el Master (proceso de rango 0) los
elementos de la matriz resultado. Otra posibilidad consiste en enviar la matriz B a todos los procesos
y repartir las filas de la matriz A, de tal forma que cada proceso calcule un bloque de la matriz
resultante. ¿Cuáles son los pros y contras de estas posibilidades? ¿Puede pensar en alguna otra
posibilidad más eficiente?