TOPICOS C

PROCESOS PARALELOS
Autor: Don Juan Ovando
Maestro: Doctor Pedro Alberti
Fecha: 3 de Julio de 2013

Resumen
El presente informe muestra como instalar y luego utilizar MPICH,
una libreria de procesos paralelos que funciona con memoria distribuida,
de manera local. Para ello se realiza el trabajo en el sistema operativo linux sobre la distribuicin Ubuntu, y como ejemplo de aplicacin se
implementa un algoritmo de resolucin de sistema de ecuaciones sobre
una matriz cuadrada triangular superior. Finalmente se realiza una comparacin de tiempos sobre el algoritmo ya descrito, donde se comparan la
implementacin de resolucin en paralelo versus la implementacin de resolucin en serie de la matriz, analizando los problemas y las limitaciones
que se presentan por el hecho de trabajar con slo una mquina.

Parte I

Objetivos
Los objetivos del presente trabajo son:
Instalar MPICH y analizar sus funciones principales para el paso de mensaje y la sincronizacin de procesos.
Probar MPICH con un programa de ejemplo.
Analizar e implementar un problema de resolucin de sistema de ecuaciones en una matriz triangular superior, siguiendo un modelo de resolucin en serie.
Analizar e implementar un problema de resolucin de sistema de ecuaciones en una matriz triangular superior, siguiendo un modelo de resolucin en paralelo con distribuicin de memoria utilizando la libreria
MPICH.
Calcular tiempos de resolucin para distintos tamaos de matrices para
las implementaciones del modelo serie y paralelo, y a la vez variando la
cantidad de procesos paralelos que se ejecuten (en paralelo).
Concluir los datos recopilados y analizarlos.
Analizar las limitaciones del modelo paralelo usado.

Parte II

MPICH
MPICH es un programa de biblioteca de desarrollo de libre disposicin implementacin portable de MPI, es decir, utiliza un mtodo de paso de mensajes
donde aplica memoria distribuida para cada proceso, de modo que cada proceso

computa un subresultado del problema mayor y luego existe un subproceso que

se encarga de reunir todos los subresultados para computar el resultado nal.

1. Hardware
Se utiliz el siguiente hardware para el trabajo:
Notebook Acer:

Sistema operativo: Ubuntu 12

Ram: 4GB

Procesador: Intel Core i3 CPU 1.20GHz

2. Instalacin
La instalacin de la libreria MPICH se hace por medio de la consola con el
siguiente comando.
sudo apt-get install libcr-dev mpich2 mpich2-doc
Con esta sentencia se instalar MPICH y quedar listo para su uso.
Para probar si fue instalada correctamente, implementamos el siguiente cdigo

#include <mpi.h>
#include <stdio.h>
int main (int argc, char* argv[]) {
int rank, size;
MPI_Init (&argc, &argv);
/* starts MPI */
MPI_Comm_rank (MPI_COMM_WORLD, &rank);
/* get current process id */
MPI_Comm_size (MPI_COMM_WORLD, &size);
/* get number of processes */
printf( "Hello world from process %d of %d\n", rank, size );
MPI_Finalize();
return 0;
}
Para compilar el programa
mpicc mpi.hello.c -o hello
Donde se compila 'mpi_hello.c' y se crea el archivo 'hello'.
Luego debemos ejecutar 'hello' con la instruccin 'mpirun'. Con el parmetro
'-np 2' decimos que usaremos dos procesos que ejecutaran el programa, asi se
ejecutarn dos programas.
mpirun -np 2 ./hello
La salida del programa deberia ser la siguiente

Hello world from process 0 of 2 Hello world from process 1 of 2

Cuando ejecutamos el programa, ejecutamos dos procesos, cada uno ejecuta
el programa, y comparten datos a travs de las funciones con las que se inicializa
MPICH. Por lo tanto, cada proceso sabe cuantos procesos existen ejecutando
el programa (2 procesos, entero almacenado en 'size') y cada uno realiza la
impresin en pantalla diciendo que proceso es el que realiza la impresin. Los
procesos son dos, el primer proceso es 0, y el proceso 'n' es 'n-1'.

3. Funciones de MPICH
MPICH cuenta con las siguientes funciones para realizar el contacto entre
los distintos procesos:
int MPI_Init( int *argc, char ***argv ) Inicia el entorno de MPICH.
int MPI_Comm_rank( MPI_Comm comm, int *rank ) Asigna a la variable entera 'rank' el nmero del procesador, el cual puede ser de 0 a 'n-1'.
int MPI_Comm_size( MPI_Comm comm, int *size ) Asigna a la variable
entera size la cantidad de procesos que se ejecutan en paralelo.
int MPI_Finalize( void ) Finaliza el entorno de ejecucin de MPI.
int MPI_Get_processor_name( char *name, int *resultlen ) Obtiene el
nombre del procesador.
int MPI_Barrier( MPI_Comm comm ) Bloquea el proceso hasta que todos los procesos esten en este punto.
int MPI_Send(void *buf, int count, MPI_Datatype datatype, int dest, int
tag, MPI_Comm comm) Realiza un envio con el valor de una variable,
la cantidad de valores a tomar, el tipo del dato a enviar y el proceso de
destino.
int MPI_Recv(void *buf, int count, MPI_Datatype datatype, int source,
int tag, MPI_Comm comm, MPI_Status *status) Funcin que espera por
un mensaje del proceso 'source' . Para que send y recv sincronizen, por
lo general correctamente, se deben coincidir la cantidad de datos transmitidos, el tipo de dato transmitido y deben coincidir el destino del envo
con el origen del recibimiento. De otro modo puede suceder un bloqueo
del programa, pues algun proceso puede quedar esperando innitamente
un envo.
Estas funciones son utilizadas en el programa para la resolucin de un sistema
de ecuaciones.

Parte III

PRUEBAS
Para probar la eciencia del paralelismo sobre la resolucin en serie, se utilizar un algoritmo de resolucin de un sistema de ecuaciones. El sistema de
ecuaciones viene dado por la forma matricial de Ax=B, donde A es una matriz
cuadrada triangular superior de tamao n, x corresponde a un vector de incgnitas de tamao n y B corresponde a la igualdad de cada ecuacin, represenetado
por un vector de tamao n.

4. Algoritmo
El algoritmo para resolver el sistema de ecuaciones es el siguiente:

Para 'pr'=0,1,2,...p-1
En Ppr:
Para J = m-1,m-2,...,0
Si fila J (pertenece a) Ppr /* J mod P */
Entonces Xj = bj / Ujj
y envia Xj a Pk ,k!=pr
En otro caso
Espera Xj
Para i=0,1,...,J-1
Si fila i (pertenece a) Ppr -> bpr = bpr - Upr,J * Xj

5. Implementacin
Se implementan dos programas del algoritmo, uno secuencial y otro paralelo
utilizando MPICH .

6. Resolucin serial
La resolucin serial consiste en llevar a cabo el algoritmo presentado, donde
el clculo se realizara la a la, desde la ltima columna, hasta llegar a la
primera.
La parte esencial del cdigo es la siguiente

for(i=DIM;i>=0;i--){
S=0.0;
for(j=i+1;j<DIM;j++){
S+=eqs.A[i][j]*X[j];
5

}
X[i] = (B[i]-S)/A[i][i];
}
DIM es el tamao de la matriz, A la matriz cuadrada, B el vector con las
igualdades y X son las soluciones.
Claramente se ve que el orden es

n2

pues se tienen dos ciclos anidados que

recorren la matriz en su totalidad.

7. Resolucin paralela
Para ste mtodo de resolucin es necesario tener claro ciertos puntos. Se
tendrn 'world_size' procesos funcionando a la vez, los cuales compartirn informacin por medio de las funciones send y recv. Es importante que cada proceso
sepa quin es, si tiene que enviar o recibir informacin y que debe hacer con la
informacin. Para tener un orden y decir que tarea debe hacer cada proceso, se
usan sentencias if para ver si el proceso es efectivamente el proceso que queremos
que haga cierta tarea, de lo contrario, realiza otra accin, para el caso especco,
si es el proceso, calculara X, si no, espera el valor de X. A travs de la variable
world_rank, propia de cada proceso, se sabe el nmero de cada proceso y con
world_size, el nmero de procesos.

7.1.

Distribuicin

La resolucin en paralelo para este algortimo se aborda de una forma de

distribuicin cclica. Al usarse un modelo de distribuicin de datos, se divide la
informacin de la matriz A y de los vectores X y B en partes iguales en cada
proceso que se use, por lo tanto la primera recomendacin a tener en cuenta
para el balance de los datos, es usar una cantidad de procesos de modo tal que
sea mltiplo de el tamao de la matriz, es decir, nmero de procesos = DIM.
Para distribuir la informacin se recorre la matriz, desde la la 0 a la DIM-1,
donde se asigna la la 0 al procesador 0, la siguiente la se asigna al procesador
1 y asi, de modo que la asignacin se hace mediante un

i %size = pr

, donde

i corresponde a la la actual, size corresponde a la cantidad de procesos y pr

corresponde al procesador donde se guardar la la.
Cada proceso cuenta con una matriz de tamao DIM/size,DIM. Esta es una
porcin de la matriz original A, dividida en tantas partes como procesos se
tengan. A estas se les denominar submatriz de ahora en adelante, de manera
similar ocurre con los vectores X y B.
Para ello se utiliza el siguiente cdigo.

if (world_rank == 0){
for(i=0; i<dim ;i++){
for(j=0; j<dim ;j++){
if( (i%world_size) != 0){
6

P0

P1

P2

P3

P0

P1

P2

P3

Cuadro 1: Distribuicin de las por procesador

//no envia a proceso 0

MPI_Send((&A[i][j]), 1, MPI_DOUBLE, i%world_size, 0, MPI_COMM_WORLD);
} else{
a[i/(rows-1)][j] = A[i][j];
cont1++;
}
}
} MPI_Barrier(MPI_COMM_WORLD);
if(world_rank != 0){
for(i=0; i<rows ;i++){
//recibimos y mostramos los elementos
for(j=0; j<dim ;j++){
MPI_Recv(&AUX, 1, MPI_DOUBLE, 0,0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
a[i][j] = AUX;
}
}
}
Ahora y durante el resto de la implementacin, se ver que el proceso 0
tendra una tarea especial la cual no la tiene el resto de los procesos. El proceso
0 se encarga de ciertas tareas, como en el caso mostrado, se encarga de repartir
las las a traves de la funcin MPI_Send a los otros procesos. Si el proceso que
ejecuta el programa no es el proceso 0, entonces queda a la espera de informacin
(la la que le corresponde). Existe un caso especial en el envio de las las del
proceso 0 a si mismo. Al ser los mtodos Send y Recv bloqueantes, si el proceso
0 enva la la a si misma, existe el riesgo de no recibirla nunca, pues la esta
enviando, por lo tanto se producir un deathlock y el programa quedar pegado
en un ciclo innito. Para que no suceda esto, el proceso 0 guarda de inmediato
sus las en su matriz correspondiente. Para los casos de los vectores X y B,
el proceso 0 lleva a cabo un proceso similar donde envia a cada subvector sus
correspondientes datos.
De manera grca, se tiene la reparticin de la siguiente forma:
Asi, al proceso P0 le corresponden las las 0 y 4, a P1 las las 1 y 5, y asi,
se reparten las las cclicamente.

Tmese en cuenta que en el Cuadro 1, cada 'a' corresponde a un valor al

azar de tipo double, de modo tal que se cumple que el rango de la matriz es
DIM.

7.2.

Resolucin

Una vez que se tiene la informacin distribuida, corresponde resolver el sistema de ecuaciones utilizando el algoritmo dado.
Tal como se muestra en el algoritmo, existe una divisin para calcular el ltimo X, luego se enva este valor a los otros procesos, asi, cada proceso actualiza
paralelamente su columna correspondiente a la posicin de la columna del X
calculado y realiza la resta a su B correspondiente.
El cdigo para la resolucin del sistema es el siguiente:

for(i=dim-1 ; i>=0 ; i--){

MPI_Barrier(MPI_COMM_WORLD);
//esperamos a todos los procesos para hacer el send y recv
if(i%world_size == world_rank){
if(a[fila][i]!=0)
X[fila] = b[fila]/a[fila][i];
for(k=0; k<world_size ; k++)
if(k!=world_rank)
//enviamos el valor a los otros procesos, menos a este mismo
MPI_Send(&X[fila], 1, MPI_DOUBLE, k, 0, MPI_COMM_WORLD);
fila--;
if(fila>=0)
for(l=fila; l>=0 ; l--){
a[l][i] *= AUX;
b[l] -= a[l][i];
}
}
if(i%world_size != world_rank){
MPI_Recv(&AUX, 1, MPI_DOUBLE, i%world_size, MPI_ANY_TAG, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
if(fila>=0)
for(l=fila; l>=0 ; l--){
a[l][i] *= AUX;
b[l] -= a[l][i];
}
}
Parte el ultimo proceso calculando su X y enva el valor a los otros procesos.
Los otros procesos estn a la espera del valor, una vez que lo reciben, realizan
la actualizacin de sus datos.
El orden se ve afectado por la cantidad de procesadores que se utilizen, pues
se recorreran las 'DIM/world_size' las de las submatrices, y se recorreran DIM
DIM 2
columnas, de esta forma el orden sera
world.size , as, mientras ms procesos se
tengan, ms rpido ser la resolucin del sistema.

Tamao

Tiempo (segundos)

50

0.000037

100

0.000113

150

0.000382

200

0.000851

300

0.001098

400

0.002075

1000

0.022072
Cuadro 2: Tiempos en serie

Cabe destacar el uso de la funcion MPI_Barrier(MPI_COMM_WORLD),

el cual permite mantener un orden para que los procesos que sean ms rpidos
no causen errores de bloqueo. Esto mantendra procesos ociosos, lo cual no es lo
ideal, pero para el caso es el mejor mtodo para mantener el programa sin un
bloqueo de la muerte.

Parte IV

Resultados
Para comparar ambos mtodos de resolucin, se tomaron los tiempos de
ejecucin de los programas, donde se probo a usar matrices de tamaos variables.
Para el caso serial se probaron distintos tamaos, y para el caso paralelo, adems
de variar el tamao de la matriz, se vario la cantidad de procesos a ejecutar.

8. Resultados mtodo en serie

Los tiempos en serie son los siguiente

9. Resultados mtodo paralelo

Los tiempos en paralelo son los siguientes
En el cuadro 3, no se alcanzo a calcular el tamao 1000, por un error de
Segmentation Fault. Lo mismo ocurri para el tamao 400, donde slo se pudo
calcular la mitad de las 10 iteraciones de prueba de tiempo, por lo tanto, como
puede asumir un error de falta de memoria. Para los casos de dos y cuatro
procesos sucede lo mismo, hay un momento en que la memoria no es suciente y
se realiza una cada del programa. Tambin existen casos en los que se producen
bloqueos en el programa, sto por un proceso que se mantiene en espera de un
resultado, lo cual en teora no debera pasar pues la funcin Barrier se encarga
de sincronizar los procesos.

Tamao

Tiempo (segundos)

50

0.000018

100

0.000056

150

0.000114

200

0.000198

300

0.000406

400

0.000505

1000

Cuadro 3: Tiempos en paralelo con un proceso

Tamao

Tiempo (segundos)

50

0.000165

100

0.000350

150

0.000567

200

0.000596

300

0.001427

400

0.001810

1000

Cuadro 4: Tiempos en paralelo con dos proceso

Tamao

Tiempo (segundos)

50

0.000331

100

0.000596

150

0.037002

200

300

400

1000

Cuadro 5: Tiempos en paralelo con cuatro proceso

10

Parte V

Conclusin
En base a los tiempos, se concluye que el mtodo paralelo con un proceso
en ejecucin es el mejor caso, puesto que es el que menos demora. Sin embargo,
como no era de esperarse en un principio, al aumentar la cantidad de procesos,
el tiempo aumenta en vez de disminuir, esto puede deberse a que los procesos
son ejecutados en una sola mquina que posee dos ncleos y cuatro subprocesos,
pero que no es tan inteligente como para usar este potencial, adems se hace
evidente un problema de memoria la cual colapsa a mayor cantidad de procesos
a ejecutar. Se puede producir un efecto de cuello de botella que provocara un
estancamiento de la informacin, sin embargo, se vieron totalmente bloqueados
los programas, por lo tanto esta sera una suposicin no tan probable.
La comparacin interesante es comparar el programa paralelo con un proceso
versus el programa en serie, donde se ve una mejora de tiempo en el programa
de resolucin paralela pero al llegar al tamao 1000, no cuenta con la memoria
suciente para resolver el problema. En serie, es un poco ms lento pero no tiene
problemas con el manejo de la memoria. Por lo tanto concluye que para el caso
paralelo de un proceso especcamente, se usa de manera ptima el potencial
de los dos ncleos de la mquina. Una contra-conclusin es que siempre se
use ptimamente el potencial de los ncleos, pero que el tiempo afectado sea el
tiempo de comunicacin que se vea incrementado por la velocidad y la capacidad
de los buses de transmisin.
Analizndo los grcos del anexo, se ve que el programa en para dos procesos y
el caso serie, existen mejores y peores casos alternadamente, para el caso de un
proceso claramente se ve que es mejor y contrariamente para cuatro procesos se
denota el peor caso.
De momento se cumpli con el objetivo de poder implementar un programa que
puede trabajar con mquinas en paralelo para realizar el clculo del problema
planteado, y se cumpli con el objetivo de comparar los casos en serie y en
paralelo con la condicin de trabajar con una sola mquina y las limitaciones
que se causaron.

10. Trabajo futuro

Elaborar este proyecto con un cluster de mquinas o al menos con una
mquina ms potente, que permita utilizar matrices de mayor tamao, las cuales
sean al menos 10 veces ms grandes, permitirn crear grcos mucho ms claros
para analizar y comparar los casos ya expuestos.

11

^
W

Figura 1: Comparacin serie, 1 proceso, 2 procesos

Figura 2: 4 procesos

Parte VI

Anexos
11. Grcos
Vease Figura 1: Comparacin serie,1proceso,2procesos.
Vease Figura 2 : 4 procesos.

12