OpenMPvsMPI



1.- Introducción Introducc ión ........................................... ............................................................................ ................................................................................ .................................................................... ..................... 1 2.- Desarrollo Desarro llo ................................................................ .......................................................................................................... ........................................................................... ........................................... .......... 1 2.1.- Program a Secuencial Secuencia l ................................................. .................................................................................. .......................................................................... ......................................... 1 2.1.1.- PrintMat .................................................................................... ..................................................................................................................... ...................................................... ..................... 1 2.1.2.- CopyMat ............................................................................................ ................................................................................................................................ ............................................. ......... 1 2.1.3.- CountNeighbours CountNeighb ours ......................................... ........................................................................... ................................................................................. ................................................. 2 2.1.4.- GameOfLive ...................................................................................................... ................................................................................................................................... ............................. 2 2.1.5.- InitMatrix ......................................... .......................................................................... ........................................................................ ............................................................. ...................... 2 2.1.6.- Main .......................................... ............................................................................ ................................................................................ ................................................................... ..................... 3 2.2.- OpenMP ............................................................................................. ................................................................................................................................ ................................................... ................ 3 2.2.1.- CopyMat ............................................................................................ ................................................................................................................................ ............................................. ......... 3 2.2.2.- GameOfLive ...................................................................................................... ................................................................................................................................... ............................. 3 2.2.3.- Main .......................................... ............................................................................ ................................................................................ ................................................................... ..................... 4 2.3.- MPI ............................................ ............................................................................. ................................................................................ .......................................................................... ........................... 4 2.3.1.- CopyMat ............................................................................................ ................................................................................................................................ ............................................. ......... 4 2.3.2.- CountNeighbours CountNeighb ours ......................................... ........................................................................... ................................................................................. ................................................. 4 2.3.3.- GameOfLife GameOfLif e ........................................... ............................................................................ ......................................................................... ....................................................... ............... 5 2.3.4.- FillExtended ........................................... ............................................................................ ......................................................................... ....................................................... ............... 5 2.3.5.- Main .......................................... ............................................................................ ................................................................................ ................................................................... ..................... 5 3.- Resultados ......................................... .......................................................................... ............................................................................... .......................................................................... ............................ 7 3.1.- Secuencial Secuencia l ................................................................................................................ ............................................................................................................................................. ............................. 7 3.2.- OpenMP ............................................................................................. ................................................................................................................................ ................................................... ................ 8 3.3.- MPI ............................................ ............................................................................. ................................................................................ .......................................................................... ........................... 9 4.- Conclusiones Conclusione s ........................................................................................................... ............................................................................................................................................. .................................... 11 5.- Anexo: Indicaciones de compilación y ejecución ................................................................................... 12 5.1.- Secuencial Secuencia l ................................................................................................................ ........................................................................................................................................... ........................... 12 5.2.- OpenMP ............................................................................................. ................................................................................................................................ ................................................. .............. 12 5.3.- MPI ............................................ ............................................................................. ................................................................................ ........................................................................ ......................... 12

Introducción a la Computación Paralela

Máster SIANI

.+,#!$ El presente trabajo constituye la entrega del trabajo de curso de la asignatura Introducción a la Computación Paralela, del Máster Universitario en Sistemas Inteligentes y Aplicaciones Numéricas en la Ingeniería. Consiste en la implementación del Juego de la Vida de Conway de forma secuencial y paralela. Esta última se realiza haciendo uso de las librerías OpenMP y MPI. Dado que se trata de un problema clásico, en esta memoria se obviará la explicación del mismo. También, ya que los conceptos fundamentales de las citadas librerías se han visto en clase, no se hará descripción alguna de las mismas, salvo que fuera necesario en alguna parte de la solución desarrollada. De esta forma, en las siguientes secciones se verá: en la parte de desarrollo se describirá la solución adoptada, tanto para la versión secuencial como para las versiones paralelas. En el apartado de resultados se verán cuáles son las salidas que se han obtenido, considerando que se han hecho simulaciones para diferentes tamaños del grid y diferentes configuraciones en las versiones paralelas. Por último, en la sección de conclusiones, se hará un análisis de los resultados que se han obtenido.

/+,"!! En esta sección se describirá la solución implementada, tanto su versión secuencial como las versiones  paralelas. Inicialmente se describirá la primera, para posteriormente indicar cuáles han sido las modificaciones necesarias para la obtención de las otras dos. En principio, este proceso es casi trivial en el caso de OpenMP, mientras que en el caso de MPI es preciso realizar un mayor número de cambios.

/+.+,!!$ Una de las consideraciones previas que se deben tener al comenzar es decidir si se va a hacer o no un tratamiento toroidal del grid. Aunque en las primeras fases, por simplicidad, se tomó la decisión de no hacerlo, finalmente se ha incorporado esta funcionalidad. El tratamiento que se realiza en este sentido es igual tanto en este caso, el secuencial, como en la implementación en OpenMP. Sin embargo, en el caso del desarrollo en MPI, se han hecho ligeros cambios, los cuáles serán descritos en el apartado 2.3. La implementación está compuesta por un conjunto de funciones. Es por ello que en los siguientes apartados se va a tratar de describir todas y cada una de ellas, en el mismo orden en el que se pueden encontrar en el fichero correspondiente. Dicho archivo es el denominado como “sequential.cpp” .

/+.+.+,!## Este procedimiento es el encargado de imprimir en un fichero el resultado de las sucesivas iteraciones. Para ello se hace uso de la librería fstream de C++ para el tratamiento de ficheros. Recibe como parámetros un puntero al vector que representa el grid y la dimensión del mismo. Dependiendo de la dimensión del grid, se crea un fichero que comienza por “output_grid_X” donde X es el tamaño de la matriz. El fichero siempre se abre en modo adición, de forma que si este ya existe, el resultado se añadirá al final del mismo. Dentro del fichero se representa la matriz donde cada posición está asociada a un símbolo. Si el elemento está vivo, es decir, su valor es 1, se escribirá en el fichero un asterisco “*”. Sin embargo, si está muerta, se escribirá un punto “ ”. Al terminar, se deja un espacio doble. De esta manera es sencillo diferenciar entre una iteración y la siguiente.

/+.+/+,'# Este procedimiento se ocupa de copiar una matriz en otra. Debido a que el proceso va escribiendo en la  posición asociada de la matriz, siempre se tiene una copia del resultado de la iteración anterior para realizar  la actualización. Recibe como parámetros dos punteros uno al vector de la matriz y otro a la copia, además del tamaño.

Página 1

Introducción a la Computación Paralela

Máster SIANI

Una vez terminada la iteración se invoca a CopyMat para que actualice la matriz y así pasar a la siguiente iteración.

/+.+0+,$#$!" Esta función es la encargada del conteo de los vecinos de una posición dada, usando la vecindad de Moore, es decir, sus ocho vecinos. Para ello se actualizan en cada caso los valores de ocho variables que representan las ocho diferentes posiciones: esquina superior izquierda, borde superior, esquina superior  derecha, borde izquierdo, borde derecho, esquina inferior izquierda, borde inferior y esquina inferior derecha. Recibe como parámetros el puntero al vector, la posición (i,j) y el tamaño. En primer lugar se tiene en cuenta el caso general, es decir, que se esté dentro de la matriz. Para ello los índices (i,j) de la posición indicada han de ser ambos mayores que cero e inferiores a la dimensión de la matriz. Si no es así, se comienza a chequear si estamos en alguno de los casos descritos anteriormente: las cuatro esquinas o los cuatro bordes. En cada uno de dichos casos se actualiza adecuadamente el valor que se ha de coger del vecino adecuado, accediendo a la posición correcta del vector que representa el grid. Un ejemplo de este procedimiento puede verse en la ilustración 1.

(n-1,n-1)

(n-1,0)

(n-1,1)

(0,n-1)

(0,0)

(0,1)

(1,n-1)

(1,0)

(1,1)

Ilustración 1: ejemplo de tratamiento toroidal para la esquina superior izquierda. En azul el elemento a tratar, en verde sus vecinos adyacentes y en rojo sus vecinos toroidales

Finalmente se devuelve el valor correspondiente a la suma de los valores de esos ocho vecinos ya que cada uno de ellos sólo puede valor cero o uno, en función de si está muerto o vivo respectivamente.

/+.+1+,% Este procedimiento es el encargado de realizar el Juego de la Vida de Conway. Para ello recibe por   parámetro el puntero a la matriz, la copia de la misma que es la que se actualiza y el tamaño . Simplemente se recorre toda la matriz y va invocando a la función anterior, CountNeighbours, para saber  cuándo actualizar o no el valor asociado a cada posición. La actualización se realiza mediante una operación a nivel de bits: copy[i*size+j] = (NumNeighbours == 3) | (NumNeighbours== 2 & m[i*size+j]);

Esta operación permite hacer la actualización de una manera correcta y simple.

/+.+2+,##!& Este procedimiento se encarga de la inicialización de la matriz. Recibe un puntero al vector y el tamaño. Es dependiente de una macro denominada RAND_INIT. En función de si esta macro vale uno o cero, se  procederá a hacer una inicialización aleatoria o una conocida para hacer pruebas. Esta configuración  predeterminada es la que se muestra en el enunciado de la práctica y es la usada siempre para saber si todo está funcionando correctamente.

Página 2

Introducción a la Computación Paralela

Máster SIANI

Los valores a cero representan que la célula o elemento en cuestión está muerto y el valor uno que está vivo. En el caso de la inicialización aleatoria se hace uso de la función rand() de C++ a la que se le aplica un módulo dos, para así siempre obtener como resultado valores cero o uno.

/+.+3+, Es el programa principal. En este caso no recibe ningún tipo de parámetro. Inicialmente se tienen dos punteros, uno para la matriz y la copia de la misma. Luego se tienen dos vectores para las pruebas. El primero de ellos es para diferentes tamaños del grid: diez, cincuenta, cien, doscientos cincuenta, quinientos y mil. Este tamaño se refiere a la longitud del lado, es decir, las matrices serán de diez por diez y así sucesivamente. El otro vector es para el número de iteraciones: quinientas y mil. Además de estas variables se tienen dos más para el cómputo del tiempo al principio y al final, para saber  cuánto tarda la ejecución. Terminada la declaración de variables, se tienen dos bucles anidados, uno para iterar en el vector de tamaños de grid y el otro sobre el número de iteraciones. De esa forma se pueden hacer de manera automática las distintas pruebas. A continuación se reserva la memoria tanto para el grid principal como para la copia del mismo. Recordemos que esto se hace así porque en el proceso del Juego de la Vida se va cambiando la matriz y se ha de tener una copia en sobre la que ir mirando las vecindades de los elementos que se van a actualizar. Una vez se ha cogido la memoria, se inicializa el vector y se obtiene el valor para la variable inicial del tiempo. Se hace la primera copia del array y se comienzan las iteraciones. En cada una de las iteraciones, si no se está computando el tiempo (macro COMPUTE_TIME a cero) se realiza la impresión del grid invocando al procedimiento PrintMat, para ir viendo el proceso en un fichero. Realmente el tiempo se computa siempre y esta macro sólo sirve para determinar si se escribe o no en el fichero de salida. Obviamente, además de dicha impresión, en cada iteración se invoca al procedimiento GameOfLive anteriormente descrito. Una vez finaliza el bucle se determina el tiempo final. Posteriormente, se imprime el último estado del grid (teniendo en cuenta el valor de COMPUTE_TIME ) y se muestra por pantalla un mensaje que indica el tamaño del grid, las iteraciones realizadas y el tiempo transcurrido en dicha operación. Antes de pasar al siguiente valor para las iteraciones o tamaño, se libera la memoria alojada para el vector   principal y la copia del mismo.

/+/+, La paralelización del código usando la librería OpenMP es casi inmediata. Simplemente es necesario para empezar incluir la librería omp.h. La solución en la que se ha usado OpenMP se encuentra en el fichero “openmp.cpp” . En el proceso de paralelización del código es preciso tener en cuenta que oportunidades de procesamiento  paralelo se tienen en él. En nuestro desarrollo se encuentran principalmente dos: una de ellas es en el proceso del Juego de la Vida y la otra en la copia del vector principal en un vector soporte.

/+/+.+,'# Ya que se trata de un bucle, simplemente es necesaria añadir la directiva de paralelización de un bucle  para que OpenMP lo procese. Es decir: #pragma omp parallel for for(int i=0; i