ALGORITMO PARALELO PARA LA

RESOLUCIN DE SISTEMAS DE
ECUACIONES APLICABLES AL MTODO
DE LOS ELEMENTOS FINITOS


Mroginski, Javier L. - Di Rado, H. Ariel
Beneyto, Pablo A. - Awruch, Armando M.
UNIVERSIDAD NACIONAL DEL NORDESTE
FACULTAD DE INGENIERIA
INTRODUCCIN
Con el devenir de los aos y el desarrollo industrializado de las computadoras
personales (PC), muchos problemas de la ingeniera que estaban restringidos a grupos
selectos de investigacin hoy pueden ser resueltos empleando computacin paralela.
Existen muchas formas de implementar una estacin de computadoras en paralelo, sin
embargo la mas econmica probablemente resulta ser la denominada Clusters
Beowulf. En estos computadores usualmente se ejecuta un nico programa en una PC
(servidor) que reparte la tarea a las dems PC (nodos) por medio de una interfase de
mensajera (ej. MPI, PVM, OpenMP, etc.).
Los problemas de ingeniera que representan un desafo a la tecnologa actual (ej.
Prediccin climtica, modelacin de la turbulencia, etc.) requieren un gran costo
computacional y necesitan del empleo de supercomputadoras o bien, sin que represente
un desmedro en el rendimiento, estaciones en paralelo. Tal vez la herramienta numrica
mas empleada en la actualidad para resolver los problemas ingenieriles sea el Mtodo de
los Elementos Finitos (MEF), el cual presenta en un punto crtico al momento de
paralelizar los cdigos. Dicha situacin se debe a que el MEF conduce a un sistema de
ecuaciones algebraicas lineales (SEAL) cuya resolucin debe ser abordada en paralelo.
Existen muchos mtodos de resolucin de sistemas de ecuaciones aplicables al MEF,
uno de ellos es el mtodo de Jacobi.
En el presente trabajo se muestra un algoritmo, con el cdigo fuente de F90, capaz de
resolver sistemas de ecuaciones en PC paralelas por el mtodo iterativo de Jacobi. Se
indican a su vez valores de eficiencia comparndolos con algoritmos secunciales.
MTODO DE JACOBI
Es un mtodo iterativo con el cual se resuelve el sistema lineal comenzando con una
aproximacin inicial y genera una sucesin de vectores que converge a x. Los
mtodos iterativos traen consigo un proceso que convierte el sistema en otro
equivalente de la forma para alguna matriz fija T y un vector c.
Luego de seleccionar el vector inicial la sucesin de los vectores de la solucin
aproximada se genera calculando:
c Tx x + =
1 k k
para k = 1,2,3, ...
b Ax = ( ) b x U L D = + +
El mtodo se escribe en la forma original separando A en sus partes diagonal D,
triangular inferior L y triangular superior U. Con lo cual A = D+L+U, entonces
transformamos la ecuacin,
en
, o bien
b Nx Dx + =
1 k k
con
( ) U L N + =
y explicitando el vector incgnita se tiene
ii
n
1 i j
1 k
j ij
1 i
1 j
1 k
j ij i
k
i
a x a x a b x
(
(

=

+ =

Esta demostrado que el mtodo de Jacobi as planteado converge a la solucin

cuando la matriz A es diagonalmente dominante.
BIBLIOTECAS MPI
El paquete MPI (Message Passing Interface) consiste de una serie de
bibliotecas con funciones que el programador puede utilizar en el cdigo de su
aplicacin y as transmitir la informacin entre las tareas distribuidas en los
diferentes procesadores conectados en red. Adems, provee el entorno y
protocolos sobre el sistema operativo, para que el cdigo paralelo se ejecute en
forma consistente y ordenada (esto frecuentemente se conoce como
communicator en la terminologa MPI).
La complejidad subyacente en los algoritmos en paralelo determina que no
siempre sea conveniente distribuir una tarea. Las aplicaciones de clculo
numrico (con cierta estructura algortmica) donde se requiere clculo
intensivo pueden ser paralelizados en forma eficiente. Un ejemplo tpico son
los algoritmos de inversin de matrices o de solucin de sistemas de
ecuaciones algebraicos, presentes en una gran variedad de problemas
ingenieriles que ataen al MEF.
Existen muchas distribuciones e implementaciones de MPI. En nuestro caso se
instal MPICH2 (versin 1.0.5). Este es un software de cdigo abierto y
distribucin gratuita que est disponible en Internet.
PROGRAM JacobiPar
!*** Metodo para resolver sistema de ecuaciones por el metodo de Jacobi en PARALELO
INCLUDE 'mpif.h'
INTEGER*4 N,MITER,IITER,size,myid,ierror,i,j,RETOR,REST,icolu,fcolu
ALLOCATABLE A,X,R,SUMA,ZUMA
REAL*8 ERR,XANT,A(:,:),X(:),R(:),clock,SUMA(:),ZUMA(:)
CALL MPI_INIT( ierror )
CALL MPI_COMM_RANK( MPI_COMM_WORLD, myid, ierror )
CALL MPI_COMM_SIZE( MPI_COMM_WORLD, size, ierror )
CALL MPI_BARRIER( MPI_COMM_WORLD, ierror)
IF(myid.eq.0)THEN
OPEN(UNIT=5,FILE='INDAT.DAT',FORM='FORMATTED',ACCESS='SEQUENTIAL')
OPEN(UNIT=6,FILE='SOLUTION.DAT',FORM='FORMATTED',ACCESS='SEQUENTIAL')
WRITE(*,*) 'RESOLUCION DE SISTEMAS DE ECUACIONES '
WRITE(*,*) 'POR EL METODO ITERATIVO DE JACOBI EN PARALELO'
READ(5,*)
READ(5,*) N
END IF
CALL MPI_BARRIER( MPI_COMM_WORLD, ierror)
CALL MPI_BCAST( N, 1, MPI_INTEGER, 0, MPI_COMM_WORLD, ierror)
ALLOCATE (A(N,(N+1)),X(N),R(N),SUMA(N),ZUMA(N))
!*** Generacin de un sistema de ecuaciones aleatorio
IF(myid.eq.0) CALL SISGEN(N,A,X,R,ERR,MITER)
CALL MPI_BARRIER( MPI_COMM_WORLD, ierror)
CALL MPI_BCAST(MITER,1,MPI_INTEGER,0,MPI_COMM_WORLD,ierror)
CALL MPI_BCAST(ERR,1,MPI_DOUBLE_PRECISION,0,MPI_COMM_WORLD,ierror)
CALL MPI_BCAST(A,N*N,MPI_DOUBLE_PRECISION,0,MPI_COMM_WORLD,ierror)
CALL MPI_BCAST(X,N,MPI_DOUBLE_PRECISION,0,MPI_COMM_WORLD,ierror)
clock = secnds(0.0)
!*** Inicio del Metodo de Jacobi
IITER=0
REST=MOD(N,size)
icolu = 1 + myid*(N-REST)/size
fcolu = myid*(N-REST)/size + (N-REST)/size
IF(myid.eq.(size-1)) fcolu = fcolu + REST
10 CONTINUE
RETOR=0
DO I=1,N
SUMA(I)=0.0D00
END DO
DO j=icolu,fcolu
DO i=1,N
IF(i.NE.j)THEN
SUMA(i) = SUMA(i) + A(i,j)*X(j)
ENDIF
END DO
END DO
CALL MPI_BARRIER(MPI_COMM_WORLD,ierror)
CALL MPI_REDUCE(SUMA,zuma,N,MPI_DOUBLE_PRECISION,MPI_
SUM,0,MPI_COMM_WORLD,ierror
if(myid.eq.0)then
IITER = IITER + 1
do i=1,N
XANT=X(I)
X(I)=(A(I,N+1)-zuma(i))/A(I,I)
R(I)=ABS(X(I)-XANT)
IF(R(I).gt.ERR.and.IITER.LT.MITER) RETOR=1
end do
end if
CALL MPI_BARRIER( MPI_COMM_WORLD, ierror)
CALL MPI_BCAST(RETOR,1,MPI_INTEGER,0,MPI_COMM_WORLD,ierror)
IF(RETOR.eq.1)THEN
CALL MPI_BCAST(X,N,MPI_DOUBLE_PRECISION,0,MPI_COMM_WORLD,ierror)
GOTO 10
ENDIF
!*** Impresion de los resultados
Algoritmo
EFICIENCIA EN PROGRAMAS PARALELOS
Para determinar la eficiencia de un algoritmo paralelo es necesario definir en
primer medida el speed-up, que se denota mediante
p
S
y representa el grado de aprovechamiento que hace dicho algoritmo paralelo
de los recursos fsicos del sistema. El speed-up se define mediante la
siguiente expresin:
p
s
p
T
T
S =
Donde Ts es el tiempo necesario para procesar el algoritmo en forma secuencial y
Tp es el tiempo necesario para procesar el algoritmo en forma paralelo con p
procesadores.
El valor terico mximo que puede tomar el speed-up es igual al nmero de
procesadores, p. En la prctica, en vez de utilizar el speed-up de un algoritmo
paralelo como medida de rendimiento del mismo se suele utilizar la eficiencia, ya
que proporciona una medida ms objetiva. La eficiencia de un algoritmo paralelo
se denota por Ep y se define de la siguiente forma:
p
S
E
p
p
=
Cuanto ms prxima se halle la eficiencia a la unidad tanto mejor es el
rendimiento del algoritmo paralelo, independientemente del nmero de
procesadores utilizados. La eficiencia se puede escribir de la siguiente forma:
( )
s s p s p s
s
p
s
p
p
T T pT 1
1
T pT T
T
pT
T
p
S
E
+
=
+
= = =
De las expresiones anteriores puede deducirse que la eficiencia de un
algoritmo paralelo depende del cociente
s s p
T ) T pT (
que se lo denomina isoeficiencia y se denota por I
p
. Si el valor de I
p
es
pequeo la eficiencia ser buena y a medida que este parmetro crezca la
eficiencia del algoritmo paralelo se deteriorar.
RESULTADOS
Para probar la eficiencia del algoritmo paralelo, JacobiPar, mostrado en el
Cuadro 1 se resolvieron diferentes sistemas de ecuaciones generados en forma
aleatoria manteniendo el requerimiento del mtodo de Jacobi de dominancia
diagonal de la matriz A de los coeficientes.
En la Tabla 1 se comparan los resultados del algoritmo ejecutado en 2
computadoras conectadas en paralelo y en una que posee doble ncleo, con los
resultados obtenidos de correr el problema en forma secuencial (1 procesador)
Tiempo Iteraciones Tiempo Iteraciones
100 0.002375 6 0.013781 8 0.012403 6 8.616786 9.574207
1000 0.231406 5 0.184375 5 0.165938 6 62.754237 69.726930
2000 0.943906 5 0.734719 5 0.661247 5 64.235890 71.373211
3000 2.218813 4 1.514125 5 1.362713 5 73.270453 81.411615
4000 16.986844 4 12.484406 4 11.235966 4 68.032245 75.591384
5000 28.082313 4 23.013938 5 20.712544 4 61.011534 67.790593
6000 43.155500 4 40.627906 4 36.565116 4 53.110662 59.011847
7000 78.624219 4 71.216169 4 64.094552 4 55.201101 61.334557
Eficiencia 2
Proc. Par.
Eficiencia Proc.
Core Duo
Orden
Secuencial
Tiempo Iteraciones
2 Procesadores Paralelo 2 Procesadores Core Duo
Paralelo
0.0
10.0
20.0
30.0
40.0
50.0
60.0
70.0
80.0
90.0
0 1000 2000 3000 4000 5000 6000 7000 8000
Orden del Sistema
T
i
e
m
p
o

(
s
e
g
)
Secuencial
2 Proc. en Paralelo
Proc. Core Duo

RESULTADOS
Grfico 1: Tiempo de ejecucin vs. Orden del sistema de ecuaciones
CONCLUSIONES
Se ha presentado un algoritmo, codificado en F90, para
resolver en paralelo sistemas de ecuaciones por el mtodo
de Jacobi. Los resultados obtenidos sobre sistemas
aleatorios diagonalmente dominantes muestran un mejor
rendimiento para los procesadores de doble ncleo
comparndolo con una estacin de trabajo formada con 2
PC y con el mismos algoritmo corrido secuencialmente.
Esta mejora se debe fundamentalmente a que el
procesamiento en paralelo se ve obligado a destinar un
tiempo en comunicacin en la red que no lo requiere el
procesador de doble ncleo.