Ejemplos MPI

Ejemplo MPI
Ivar Fernando Gómez Pedraza

Multiplicación de matrices
• Hacer un programa que realice la
multiplicación de dos matrices, tales que el
número de columnas de la matriz A es igual al
número de filas de la matriz B; es decir:

• la multiplicación de A por B, que se denota
A·B, A×B o simplemente AB, está definida
como:
• donde cada elemento c i,j está definido por:

Gráficamente, si
y
Entonces

Procedimiento secuencial
Un solo proceso que ejecuta:
for(i=0; i

Multiplicación de Matrices
Procedimiento paralelo
• Un proceso maestro -> distribuye las distintas
tareas al resto de procesos.
• Varios procesos worker -> calcula un cierto
número de filas de la matriz resultante y
reenvía el resultado parcial al proceso
maestro.
Num_workers = num_procesos -1

Proceso en el MAESTRO
• Conocer las matrices a multiplicar a y b
• Inicialización de las matrices a y b
• Cálculo del número de filas que hay que enviar a cada
proceso worker:
• nfilas = NFA / num_workers
• filas_extra = NFA % num_workers
• ENVIO a cada WORKER:
• Numero de filas de la matriz “a” -> nfilas o nfilas+1
• Elementos de “a” con los que debe operar -> nfilas*NCA
elementos de “a”
• Matriz “b” en su totalidad.
• ESPERAR... (mientras los workers trabajan)

• RECEPCIÓN de cada WORKER
– Subparte de la matriz resultado “c”-> nfilas*NCB
elementos.
• Atención!!! ¿¿¿dónde metemos los elementos
recibidos???
cada worker puede haber calculado un
número de filas distintas, calcular cuántas y
guardar resultado en matriz “c” con el
desplazamiento adecuado.

Fase de envío:
MPI_send
Fase
recepción:
MPI_recv

Proceso en el WORKER
• Desconoce tanto la matriz a como la b
• Recepción del MAESTRO de:
• Número de filas -> nfilas
• Elementos de a con los que va a calcular -> nfilas*NCA elementos
• Matriz b en su totalidad
• Fase de Cálculo:
for(i=0; i

Código en MPI
• Se colocan las librerías a usar
#include "mpi.h"
#include
#include
Librería de C que
contiene las
operaciones estándar
de entrada y salida
Librería que contiene
los prototipos de
funciones de C para
gestión de memoria
dinámica, control de
procesos y otras

int main (int argc, char *argv[])
{
int nsize, rank, rc, i, j, k,numworkers, /* number of worker tasks */
source, /* task id of message source */
dest, /* task id of message destination */
mtype, /* message type */
rows, /* rows of matrix A sent to each worker */
averow, extra, offset; /* used to determine rows
sent to each worker */
int NRA=4, NCA=6, NCB=3, MASTER=0;
double a[NRA][NCA], /* matriz A */
b[NCA][NCB], /* matriz B */
c[NRA][NCB]; /* matriz resultado C */
MPI_Status status;

MPI_Init(&argc,&argv);
MPI_Comm_rank(MPI_COMM_WORLD,&taskid);
MPI_Comm_size(MPI_COMM_WORLD,&numtasks);
if (numtasks < 2 ) {
printf("Need at least two MPI tasks. Quitting...\n");
MPI_Abort(MPI_COMM_WORLD, rc);
exit(1);
}
numworkers = numtasks-1;

• /***************** master task ************************/
• if (taskid == MASTER)
• {
• printf("mpi_mm has started with %d tasks.\n",numtasks);
• printf("Initializing arrays...\n");
• for (i=0; i

• /* Send matrix data to the worker tasks */
• averow = NRA/numworkers;
• extra = NRA%numworkers;
• offset = 0;
• mtype = FROM_MASTER;
• for (dest=1; dest

• /* Receive results from worker tasks */
mtype = FROM_WORKER;
for (i=1; i

• /* Print results */
• printf("******************************************************\n");
• printf("Result Matrix:\n");
• for (i=0; i

• /**************************** worker task ************************************/
• if (taskid > MASTER)
• {
• mtype = FROM_MASTER;
• MPI_Recv(&offset, 1, MPI_INT, MASTER, mtype, MPI_COMM_WORLD, &status);
• MPI_Recv(&rows, 1, MPI_INT, MASTER, mtype, MPI_COMM_WORLD, &status);
• MPI_Recv(&a, rows*NCA, MPI_DOUBLE, MASTER, mtype, MPI_COMM_WORLD, &status);
• MPI_Recv(&b, NCA*NCB, MPI_DOUBLE, MASTER, mtype, MPI_COMM_WORLD, &status);
• for (k=0; k