Matriz Vector

Multiplicación Matríz-Vector Chapter 8

Bosquejo El algoritmo secuencial El diseño, analisis, y la implantación de tres programas paralelos Rowwise block striped Columnwise block striped Checkerboard block Matríces con mucho ceros (“sparse”)

Algoritmo Secuencial = = 1 2 -3 5 7 6 6 2 1 -2 7 3 2 5 -1 6 1 2 9 4 -1 77 72 27

Algoritmo Secuencail (cont) Entrada: una matríz mXn a[0..m-1,0..n-1] y un vector b[0..n-1] Salida: El producto a b = c[0..m-1] for i←0 to m-1 do c[i] ←0 for j←0 to n-1 do c[i] ← c[i] + a[i,j] endfor endfor Complexidad: O(mn)

Algoritmo I (Rowwise block striped matrix) Descomposición de dominio Una tarea primitive está asociada con una fila de la matríz y la vector entera

Un Paso del Algoritmo Paralelo Fila i de A b Fila i of A b c i Producto interior Fila i de A b c Comunicaci ón All-gather

Aglomeración y Asignación de Procesos Un número estático de tareas Un patron regular de comunicaciones (all-gather) El tiempo de computación por tarea es constante Estrategia: Aglomerar grupos de filas

Bloque Vectorial a Vector Replicado Se unen los bloques de cada proceso y se manda el resultado a cada proceso mediante Allgatherv

MPI_Allgatherv int MPI_Allgatherv ( void *send_buffer, int send_cnt, MPI_Datatype send_type, void *receive_buffer, int *receive_cnt, int *receive_disp, MPI_Datatype receive_type, MPI_Comm communicator)

Función create_mixed_xfer_arrays Una función para computar los argumentos Primer arreglo La cantidad de elementos contribuidos por cada proceso Usa el macro BLOCK_SIZE Secundo arreglo Primera posición del buffer donde recibe Presumir que los buffers están en el orden de rango

Función replicate_block_vector Crear espacio para el vector entero Crear arreglos “mixed transfer” Hacer llamada a MPI_Allgatherv

Rowwise block striped matrix-vector multiplication /* /* This program multiplies a matrix and a vector input from a separate files. The result vector is printed to standard output Data distribution of matrix: rowwise block striped Data distribution of vector: replicated */ #include <stdio.h> #include <mpi.h> #include "../MyMPI.h" /* Change these two definitions when the matrix and vector element types change */ typedef double dtype; #define mpitype MPI_DOUBLE

Matrix-vector multiplication(cont) int main (int argc, char *argv[]) { dtype **a; /* First factor, a matrix */ dtype *b; /* Second factor, a vector */ dtype *c_block; /* Partial product vector */ dtype *c; /* Replicated product vector */ double max_seconds; double seconds; /* Elapsed time for matrix-vector multiply */ dtype *storage; /* Matrix elements stored here */ int i, j; /* Loop indices */ int id; /* Process ID number */ int m; /* Rows in matrix */ int n; /* Columns in matrix */ int nprime; /* Elements in vector */ int p; /* Number of processes */ int rows; /* Number of rows on this process */ int its;

Matrix-Vector Multiplication(cont) MPI_Init (&argc, &argv); MPI_Comm_rank (MPI_COMM_WORLD, &id); MPI_Comm_size (MPI_COMM_WORLD, &p); read_row_striped_matrix (argv[1], (void *) &a, (void *) &storage, mpitype, &m, &n, MPI_COMM_WORLD); rows = BLOCK_SIZE(id,p,m); print_row_striped_matrix ((void **) a, mpitype, m, n, MPI_COMM_WORLD); read_replicated_vector (argv[2], (void *) &b, mpitype, &nprime, MPI_COMM_WORLD); print_replicated_vector (b, mpitype, nprime, MPI_COMM_WORLD);

Matrix-Vector Multiplication (cont) c_block = (dtype *) malloc (rows * sizeof(dtype)); c = (dtype *) malloc (n * sizeof(dtype)); MPI_Barrier (MPI_COMM_WORLD); seconds = - MPI_Wtime(); for (i = 0; i < rows; i++) { c_block[i] = 0.0; for (j = 0; j < n; j++) c_block[i] += a[i][j] * b[j]; } replicate_block_vector (c_block, n, (void *) c, mpitype, MPI_COMM_WORLD); MPI_Barrier (MPI_COMM_WORLD); seconds += MPI_Wtime();

Matrix-Vector Multiplication(cont) print_replicated_vector (c, mpitype, n, MPI_COMM_WORLD); MPI_Allreduce (&seconds, &max_seconds, 1, mpitype, MPI_MAX, MPI_COMM_WORLD); if (!id) { printf ("MV1) N = %d, Processes = %d, Time = %12.6f sec,", n, p, max_seconds); printf ("Mflop = %6.2f\n", 2*n*n/(1000000.0*max_seconds)); } MPI_Finalize(); return 0; }

Analisis de Complexidad Complexidad del algoritmo secuencial:  ( n 2 ) Complexidad computacional del algoritmo paralelo:  ( n 2 /p ) Complexidad de comunicación de all-gather:  (log p + n ) Complexidad General:  ( n 2 /p + log p )

Analisis de Complexidad de All-gather Una manera eficiente para efectuar All-gather es llevar a cabo las comunicaciones en forma de un hipercubo. Un hipercubo es una red con 2 n nodos numerados en binario tal que hay un arco entre dos nodos si y solo si los n úmeros binarios asociados difieren en exactamente una posición.

Complexidad de All-gather All-gather se puede efectuar en log p pasos mediante una red hipercubo de p=2 n procesos. La demostración es por inducción en n : Si n=1 , All-gather se puede efectuar haciendo un intercambio. Supongamos que All-gather se puede efectuar en n=log p pasos en un hipercubo de tamaño p=2 n . Sea R un hipercubo con p=2 n+1 procesos. Entonces R se puede particionar en dos hipercubos, cada uno de tamaño 2 n y por la hipotesis de inducción All-gather se puede efectuar en cada una de estas subredes en n pasos. Luego, en un paso mas de intercambios, todo proceso contendrá todos los datos originales.

Complexidad de All-gather (cont) Enviar un mensaje que contiene n datos requiere tiempo λ + n/ β donde λ es latencia ( el tiempo que se necesita para iniciar un mensaje) y β ancho de banda (el n úmero de datos que se puede enviar por un canal en una unidad de tiempo)

Complexidad de All-gather (cont) La cantidad de datos que se intercambian se dobla en cada uno de los log p pasos El tiempo total para efectuar All-gather es Σ i ( λ + 2 i-1 n/ β ) donde i varia de 1 a log p . Pero Σ i ( λ + 2 i-1 n/ β ) = λ log p + (p-1)n/ β

Complexidad de Comunicaciones En el algoritmo para multiplicar una matriz por un vector utilizando descomposición de filas, la cantidad de datos envueltos en All-gather es  n/p  . La complexidad de comunicaciones en el algoritmo de es  (log p + n)

Multiplicación Matríz Vector Descomposición Checkerboard

Diseño del Algoritmo Asociar una tarea primitiva con cada elemento de la matríz A Cada tarea primitive hace una multiplicación Aglomerar tareas primitivas en bloques rectangulares Procesos constituyen una parrilla bidimensional Distribuir el vector b en los procesos de la primera columna de la parrilla

La Tareas después de la Aglomeración

Redistribuir el Vector b Paso 1: Mover b de la primera columna a la primera fila Si p es es un cuadrado Procesos en la primera columna envian sus pedazos de b a procesos de la primera fila Si p no es un cuadrado Acumula (“gather”) b en el proceso (0, 0) El process (0,0) emite (“broadcasts” a los procesos en la primera fila Paso 2: Los procesos de la primera fila esparce b dentro de las columnas

Comunicadores Queremos procesos en una parrilla virtual de dos dimensiones Necesitamos crear comunicadores para hacer esto Necesitamos hacer broadcasts y reduciones dentro de subconjuntos de procesos

Comunicadores Un comunicador consiste de un grupo de procesos un contexto una topología

Para Crear una Parrilla Vitual de Procesos MPI_Dims_create parametros de entrada número de procesos en la parrilla deseada número de dimensiones Devuelve el número de procesos en cada dim MPI_Cart_create Crea un comunicador con una topología cartesiana

MPI_Dims_create int MPI_Dims_create( int nodes, /*el número de procesos en la parrilla*/ int dims, /* el número de dimensiones */ int *tamano/* el tamano de cada dimension*/)

MPI_Cart_create MPI_Cart_create( MPI_Comm com_viejo, int dims, int *size,/*un arreglo de tamano dims*/ int *periodico, /*un arreglo de tamano dims, periodico[j]=1 si se desea “ wraparound” en la dimension j*/ int reordenar, /*0 si rango en el nuevo comunicador es lo mismo como en el viejo*/ MPI_Comm *com_cart)

Dos Funciones Relacionadas con Parrillas MPI_Cart_rank Devuelve el rango del proceso, dada las coordenadas del proceso en un comunicador cartesiano MPI_Cart_coords Devuelve las coordenadas cartesianas de un proceso, dado su rango.

MPI_Cart_rank int MPI_Cart_rank ( MPI_Comm com, int *coords, int *rango)

MPI_Cart-coords int MPI_Cart_coords ( MPI_Comm com, /* In - Communicator */ int rango, int dims, int *coords)

Ejemplo #include <stdio.h> #include <mpi.h> int main (int argc, char **argv) { MPI_Comm com_cart; int id; int p; int size[2]; int periodo[2]; int coords[2]; MPI_Init (&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &p); size[0]=size[1]=0; MPI_Dims_create(p,2,size); MPI_Cart_create(MPI_COMM_WORLD,2,size,periodo,1,&com_cart); MPI_Comm_rank(com_cart,&id); MPI_Cart_coords(com_cart,id,2,coords); printf("id=%d, (%d,%d)\n",id,coords[0],coords[1]); return 0}

MPI_Comm_split MPI_Comm_split(MPI_Comm com_viejo , int particion ,int orden_rango , MPI_Comm *com_nuevo ) Particiona un comunicador existente com_viejo en una o mas particiones. Se agrupan todos los procesos que tienen el mismo número particion El rango en el nuevo comunicator se da por orden_nuevo

Ejemplo En el ejemplo anterior, se puede hacer un comunicador de la primera columna de com_cart: MPI_Comm_split( com_cart,coords [ 1 ]==0, coord s[ 0 ],& com_col )

Leer un vector b de un archivo y distribuirlo en com_col Hacer uso de read_block_vector en MyMPI.c

Analisis de Complexidad (presumiendo que m=n) Cada proceso hace su parte de la computación:  ( n 2 / p ) Redistribuir b :  ( n /  p + log p ( n /  p )) =  ( n log p /  p ) Reducción de los vectores de resultados parciales:  ( n log p /  p ) La complexidad paralela total:  ( n 2 / p + n log p /  p )

Analisis de Isoeficiencia Complexidad Secuencial:  ( n 2 ) Complexidad de comunicación:  ( n log p /  p ) La función de Isoeficiencia: n 2  Cn  p log p  n  C  p log p M(n)=n 2  M(C  p log p)/p = C 2 log 2 p

Comparación de los tres Métodos C 2 log 2 p  ( n 2 / p + n log p /  p ) Checkerboard C p  ( n 2 /p + n log p ) Columnwise Block-Striped C 2 p  ( n 2 /p + n+ log p ) Rowwise Block-Striped Isoeficiencia Complexidad Algoritmo

Matriz Vector

Más contenido relacionado

La actualidad más candente (20)

Similar a Matriz Vector (20)

Matriz Vector