Generación de Mallas de Elementos Finitos en Paralelo

UNIVERSIDADDEMENDOZA
FACULTADDEINGENIERA
INGENIERAENINFORMTICA
GENERACINDEMALLASDEELEMENTOSFINITOSEN
PARALELO
Autor:
EmilianoLpez
Asesores:
Mg.Ing.JuanJosCiarlante
Dr.Ing.CarlosGarcaGarino
2007
RESUMEN
PROGAM es un programa muy viejo, escrito en FORTRAN IV, que genera mallas
estructuradasdeelementosfinitos.Estetrabajoconsisteeneldesarrollodeunanueva
versin del programa, denominada PROGAMP, diseada para correr en un cluster
beowulf. Como primer paso se realiz una nueva implementacin del PROGAM en
Fortran90,quesirvicomopuntodepartidaparaprogramarlaversinparalela,lacual
utilizalabibliotecaMPIparaimplementarelparalelismo.
Utilizando20procesadores,elPROGAMPgenerunamalladeelementosfinitos13
vecesmsrpidoqueelPROGAM,loqueequivaleaunaeficienciadel65%.
Losclustersbeowulf representanunaalternativasumamenteeconmicaalahorade
implementarunamquinaparalela.Desdeelpuntodevistadelrendimientolosresultados
obtenidos con el PROGAMP son muy buenos. Sin embargo, antes de paralelizar un
determinadoalgoritmo,esnecesarioestudiarqupartesdel mismosonconcurrentesy
culesno,yaqueenmuchoscasosunenfoqueparalelonoeslamejorsoluci n.
GeneracindeMallasde
ElementosFinitosenParalelo 2 EmilianoLpez
NDICEGENERAL
I.INTRODUCCIN.................................................................................................................4
II.MARCOTERICOYANTECEDENTES...........................................................................7
III.DESARROLLODEINGENIERA....................................................................................28
IV.RESULTADOS................................................................................................................40
V.CONCLUSIONES.............................................................................................................47
VI.REFERENCIAS...............................................................................................................49
VII.CDIGOFUENTE.........................................................................................................51
GeneracindeMallasde
I. INTRODUCCIN
GeneracindeMallasde
INTRODUCCIN
La programacin de algoritmos complejos con un enfoque secuencial, es cada vez
menos factible debido a problemas en la eficiencia de cmputo. El desarrollo de la
computacindealtorendimientohadadolugarauncrecimientosostenidodelademanda
de potencia de clculo, que no es posible satisfacer con arquitecturas basadas en
esquemassecuenciales.
Frenteaesteproblemaexistendosalternativas.Unadeellassebasaenelusode
computadorasconarquitecturasparalelas,quetienenporlogeneraluncostoprohibitivo
paralamayoradelasorganizaciones.Laotraopcin,muchomseconmica,consiste
en implementar clusters beowulf, los cuales estn formados por un conjunto de PCs
interconectadasenred,ycoordinadasporunsoftwarequepermitehacerlastrabajarcomo
sisetrataradeunasolamquinaparalela.
Este Trabajo Final trata de la extensin a entornos paralelos del Programa de
Generacin Automtica de Mallas (PROGAM), un software que genera mallas
estructuradas de elementos finitos. El mtodo de elementos finitos (MEF) es un
procedimientonumricopararesolverecuacionesdiferenciales,ampliamenteutilizadoen
elcampodelafsicaylaingeniera.
EltrabajofuerealizadoenelLaboratoriodeProducci nIntegradaporComputadora
(LAPIC), ubicado en la sede de la carrera Redes y Telecomunicaciones del ITU
(UNCuyo). Dicho laboratorio cuenta con un cluster beowulf para realizar trabajos de
investigacinvinculadosalacomputacindealtorendimiento.
Objetivos
1. Realizar una nueva implementacin del PROGAM en Fortran 90, ya que el
programaoriginalestescritoenFORTRANIVyslosedisponedeunaversin
GeneracindeMallasde
impresadelcdigofuente.
2. Realizar una implementacin paralela del PROGAM para ser ejecutada en un
clusterbeowulf,utilizandolabibliotecadepasodemensajesMPI.
3. Estudiar el rendimiento del programa paralelo poniendo especial nfasis en la
comparacinconlaversinsecuencial.
4. DotaralLAPICdeungeneradordemallasestructuradasdeelementosfinitosque
seadeutilidadparalostrabajosdeinvestigacinqueallserealizan.
GeneracindeMallasde
II.MARCOTERICOYANTECEDENTES
GeneracindeMallasde
ELMTODODEELEMENTOSFINITOS
El mtodo de elementos finitos (MEF) es un procedimiento numrico para resolver
ecuacionesdiferenciales,ampliamenteutilizadoenelcampodelafsicaylaingeniera.
El concepto fundamental del MEF es que cualquier funci n continua, como
temperatura,presin,odesplazamiento,puedeseraproximadaporun modelodiscreto
formado por un conjunto de funciones continuas definidas sobre un nmero finito de
subdominios.
Construccindelmodelodiscreto
Elmodelodiscretoseconstruyedelasiguientemanera:
1. Se identifica un nmero finito de puntos en el dominio. Estos puntos son llamados
nodos.
2. Elvalordelafuncincontinuaencadapuntonodaldebeserdeterminado.
3. El dominioesdivididoenunnmerofinitodesubdominiosdenominadoselementos.
Estos elementos estn conectados por los nodos y juntos aproximan la forma del
dominio.
4. Lafuncincontinuaesaproximadaencadaelementoporunpolinomioquesedefine
utilizandolosvaloresdelafuncinenlosnodosquecorrespondenalelemento.Para
cada elemento se define un polinomio diferente, pero los polinomios se deben
seleccionardemaneratalquesemantengalacontinuidadalolargodelasfronteras
delelemento.
Elconceptofundamental quedarmsclarousandocomoejemploladistribucinde
temperaturaenunabarra,comosemuestraenlaFigura1.LafuncincontinuaesT(x)y
eldominioeselintervalo0,Lalolargodelejex.Seidentificancincopuntoseneldominio
GeneracindeMallasde
(Figura2a),estospuntossonlosnodos,ynoesnecesarioqueseanequidistantes.Se
podrahaberdefinidomsdecincopuntos,peroconestosessuficienteparailustrarlos
conceptos bsicos. Se calcula en cada nodo el valor de T(x), esto se muestra
grficamenteenlaFigura2b.
Figura 1: Distribucin de temperatura en
una barra.
Figura 2: Definicin de los puntos nodales.
La divisin del dominio en elementos se puede realizar de dos maneras. Podemos
limitarcadaelementoadosnodos,obteniendocuatroelementos(Figura3a),opodemos
dividireldominioendoselementos,cadaunocontresnodos(Figura3b).Elpolinomioen
GeneracindeMallasde
cada elemento se define utilizando los valores de T(x) en los puntos nodales. Si
subdividimoslareginencuatroelementoshabrdosnodosporelementoylafuncin
elemental ser lineal. La aproximacin final de T(x) consistir de cuatro funciones
continuaslineales,cadaunadefinidasobreunelemento(Figura4a).
Figura 3: Divisin del dominio en elementos.
Ladivisindeldominioendoselementospermitequelospolinomioselementalessean
de segundo grado. La aproximacin final de T(x) en este caso sern dos funciones
continuascuadrticas(Figura4b).
GeneracindeMallasde
Figura 4: Aproximacin final de T(x).
Generalmenteladistribucindetemperaturasedesconoce,ysedeseadeterminarlos
valores de la funcin en ciertos puntos. El procedimiento es igual al que se describi
anteriormenteperoconunpasoadicional.Sedefineunconjuntodenodosylosvalores
T
1
,T
2
,T
3
,...,sonahoravariablesdesconocidas.Eldominioesdivididoenelementos,yse
defineencadaunodeellosunaecuacindetemperatura.Losvaloresnodalesde T(x)
deben ser ajustados de manera que provean la mejor aproximaci n posible a la
distribucin real. El ajustese realizaminimizando algunafuncin asociada al problema
fsico. Cuando se consideran problemas de transferencia de calor, se minimiza un
funcionalrelacionadoconlaecuacindiferencialquegobiernaelproblema.Elprocesode
minimizacin produce un sistema de ecuaciones algebraicas lineales que puede ser
resueltoparaobtenerlosvaloresnodalesdeT(x).
ElconceptobsicodelMEFpuedeseraplicadoadominiosdedosytresdimensiones.
GeneracindeMallasde
Loselementosenundominiobidimensionalsonfuncionesde xey,ygeneralmenteson
tringulos o cuadrilteros. La funcin elemental puede ser un plano (Figura 5), o una
superficie curva (Figura 6). El plano est asociado al mnimo nmero de nodos por
elemento,queestresparaeltringuloycuatroparaelcuadriltero.
Figura 5: Elementos planos en un dominio
bidimensional.
La funcin elemental puede ser una superficie curva si se agregan ms nodos,
adems,estopermitequeloselementostenganfronterascurvas.Laaproximaci nfinal
delafuncincontinua d x , y) serunacoleccindesuperficies,cadaunadefinida
sobreunelementoutilizandolosvaloresde d x , y) enlospuntosnodales.
Figura 6: La funcin elemental es una superficie
curva.
Lacapacidaddesepararunelementodelrestodeloselementosconelpropsitode
GeneracindeMallasde
definirlafuncinelemental esunaspectoimportantedel MEF.Estapropiedadpermite
que la funcin elemental sea definida independientemente de la posici n final del
elemento en el modelo conectado, e independientemente de las otras funciones
elementales.
Generacin de la malla de elementos finitos
Lageneracindelamalladeelementosfinitosconstituyeelpunto3enelprocesode
construccindelmodelodiscreto,presentadoalcomienzodeestecaptulo.Elrestodelos
puntosestnfueradelalcancedeesteTrabajoFinal,yslofuerondescriptosparaubicar
allectorenuncontextoadecuado.
Lamalladeelementosfinitoseselresultadodeladivisi ndeldominiodeunafuncin
ensubregiones oelementos. Para esto el ingeniero debe decidir el nmero, tamao y
formadeloselementosqueutilizarparamodelarelcuerporeal.Enlaszonasendonde
lafuncinaaproximarvaraconrapidez(gradientesaltos)seutilizanelementospequeos
para lograr una buena aproximacin, mientras que en las zonas donde la funcin es
relativamenteconstante,sepuedeincrementareltamaodeloselementosparareducirel
esfuerzocomputacional.Lageneracindelamallasecompletaconlanumeracindelos
nodosyloselementos.
Este trabajo se ocupa de la divisin de dominios bidimensionales en elementos
triangulares o cuadrangulares lineales, es decir que los elementos a utilizar ser n el
tringulodetresnodosyelcuadrilterodecuatronodos.
La divisin de cualquier dominio bidimensional debe comenzar con la divisi n del
cuerpoenmacroregionestriangularesocuadrangulares,deacuerdoconlageometr a,las
propiedadesfsicasdelmaterialy/olacargaaplicada.Estasregionessonluegodivididas
en tringulos o cuadrilteros, siendo necesario en el primer caso dividir la regi n en
cuadrilterosparaluegodividircadacuadrilteroendostringulos.LaFigura7muestrala
GeneracindeMallasde
divisindeunaregincuadrangularenelementostriangulares.
Figura 7: Divisin de una regin cuadrangular en
elementos triangulares.
GeneracindeMallasde
COMPUTACINPARALELA
Acontinuacin seintroducenlosconceptos generalessobreprocesamientoparalelo
enclusterstipobeowulf,ysedescribelainterfazdecomunicacionesMPI,elsoftwareque
permiteelintercambiodemensajesentrelosprocesosenunambientemultiprocesador.
Elclusterbeowulf
Uncluster beowulf est formadopor un conjunto de PCs conectadasmediante una
LAN,conunainfraestructuradesoftwarelibre (GNU/Linux).El hardwareutilizadoesel
que se encuentra disponible en el mercado comn, y puede ser tan simple como dos
mquinas compartiendo un sistema de archivos o tan complejo como 1024 nodos
conectados mediante una red de alta velocidad. El rendimiento es proporcional a la
cantidaddenodosinstalados,pudindoseagregaroquitarnodossegnlasnecesidades.
Desdeelpuntodevistaarquitectnicouncluster beowulf esunsistemadememoria
distribuida MIMD (multipleinstruction, multipledata). Este sistema consta de mltiples
procesadoresindependientes,esdecirquenocompartenlamemoriaprincipalsinoque
cada uno tiene su propia memoria, y colaboran entre s intercambiando mensajes
medianteunareddecomunicaciones.As,cadaprocesadorejecutasupropiasecuencia
deinstruccionesyaccedeasuspropiosdatos,almacenadosambosensumemorialocal.
Eventualmente los procesadores pueden intercambiar datos mediante el envo de
mensajesatravsdelared.
Paralelismoyconcurrencia
Sedicequedospartesdeunprogramaseprocesanenformaconcurrente,si cada
unadeellaspuedeserejecutadaenformaindependientedelaotra.Encambiodecimos
GeneracindeMallasde
queseejecutanenparalelo,si ambaspartessonprocesadasal mismotiempo,siendo
necesariocontarparaestocondosprocesadores.Podemosconcluirentonces,enquela
concurrencia es una caracterstica lgica, en tanto el paralelismo es una caracterstica
fsica.Porlotantoparaqueunatareapuedaserejecutadaenformaparaleladebeser
concurrente.
Estoimplicaquealahoradeplantearlasolucinaunproblema,debemosdeterminar
qu partes del mismo son concurrentes y cules no, lo cual hace que no todos los
programasseanparalelizables.
LainterfazdepasajedemensajesMPI
ElmtodomsusadoenlaprogramacindesistemasdememoriadistribuidaMIMD
es el pasaje de mensajes, o alguna variante de ste. Bsicamente, los procesos
coordinansusactividadesenviandoyrecibiendomensajes.
MPIesunestndardesarrolladoporelMessagePassingInterfaceForum(MPIF),con
elobjetivodecrearunainterfazdeprogramacinparaelintercambiodemensajesentre
procesos.DadoqueMPIesunestndarabierto,existendiversasimplementaciones,para
distintos lenguajes y arquitecturas, siendo las ms difundidas MPICH y LAM/MPI.
Adems,unmismoprogramapuedesercompiladotantoparaejecutarseenun cluster
beowulf, como en una computadora con una arquitectura paralela nativa, sin hacerle
modificaciones.
LabibliotecaMPIesunaAPIqueocultaalprogramadorlosdetallesdelmanejodelas
comunicacionesentreprocesos,ofreciendodeestemodounentornotransparentepara
desarrollar programas paralelos. Las dos funciones ms elementales que provee son
MPI_SEND y MPI_RECV, para enviar y recibir un mensaje respectivamente; a
continuacinsemuestralasintaxisdeestassubrutinasenFortran:
GeneracindeMallasde
MPI_SEND(buffer,count,dataype,destination,tag,communicator,ierr)
MPI_RECV(buffer,count,datatype,source,tag,communicator,status,ierr)
Todoslosparmetrossonenteros,aexcepcindebuffer,quepuedeserdecualquier
tipo, dependiendodel tipodedatosatransmitir.El parmetroierr esunargumentode
salidaquecumplelafuncindevalorderetorno,indicandosihuboonoerrordurantela
ejecucindelarutina.
MPIleasignaacadaprocesoenejecucinunidentificadornicodenominado rank,
quedandolosprocesosnumeradosentre0yp1,dondepeselnmerototaldeprocesos.
Cadaprocesoobtienesurankcomosigue:
CALLMPI_COMM_RANK(MPI_COMM_WORLD,my_rank,ierr)
Deestamaneraelrankdelprocesoquedarguardadoenlavarialblemy_rank.
Parailustrarelusodeestasfunciones,supongamosqueelproceso0quiereenviaral
proceso1el vectorx,compuestopor dieznmerosreales. Paraesto debellamarala
subrutinaMPI_SENDcomosigue:
CALLMPI_SEND(x,10,MPI_REAL,1,0,MPI_COMM_WORLD,ierr)
Pararecibirelmensaje,elproceso1debellamaraMPI_RECVdelasiguientemanera:
CALLMPI_RECV(x,10,MPI_REAL,0,0,MPI_COMM_WORLD,status,ierr)
Ntesequelainstruccionesejecutadasporelproceso0(MPI_SEND)serndiferentes
delasejecutadasporelproceso1(MPI_RECV).Sinembargoestonosignificaquelos
programas deban ser diferentes. Simplemente podemos incluir la siguiente estructura
condicionalennuestrocdigo:
CALLMPI_COMM_RANK(MPI_COMM_WORLD,my_rank,ierr)
GeneracindeMallasde
IF(my_rank==0)THEN
CALLMPI_SEND(x,10,MPI_REAL,1,0,&
MPI_COMM_WORLD,ierr)
ELSEIF(my_rank==1)THEN
CALLMPI_RECV(x,10,MPI_REAL,0,0,&
MPI_COMM_WORLD,status,ierr)
ENDIF
EstaformadeprogramarsistemasMIMDesllamadaSPMD(singleprogrammultiple
data).Elefectodeejecutarprogramasdiferentesselogramedianteelusodeestructuras
condicionalesenelcdigo.Esteeselenfoquemscomnutilizadoenlaprogramacin
desistemasMIMD.
Al comenzar la ejecucin en un esquema del tipo SPMD, se enva una copia del
programaacadaunodelosprocesadores.As,cadacopiadelprogramaconstituyeun
proceso. Por ejemplo, para ejecutar un programa utilizando la biblioteca MPICH2, se
utilizauncomandodesdelaconsoladelsistemaoperativodenominado mpiexec,alcual
seledancomoargumentoselnombredelejecutableylacantidaddeprocesosquese
deseacrear.
GeneracindeMallasde
PROGRAMADEGENERACINAUTOMTICADEMALLAS
(PROGAM)
El ProgramadeGeneracinAutomticadeMallas(PROGAM),escritoenFortranIV
porCarlosGarcaGarinoyC.OrtizAndino,sebasaenelprogramaGRIDpublicadopor
L.J. Segerlind, y genera datos de elementos para distintos programas de elementos
finitos. Su funcin consiste en dividir un dominio bidimensional en elementos
cuadrangularesy/otriangulareslineales.
Caractersticasdelprograma
El programa es capaz de modelar dominios bidimensionales complejos que se
obtienen como la unin de regiones ms sencillas llamadas macroelementos, cuyas
fronterasrespondenacurvasdesegundogrado(Figura8).
Dentro de cada una de estas regiones se generan, mediante interpolaci n
isoparamtrica,losnodosyelementosdelamalla.Loselementosgeneradospuedenser
tringulosocuadrilteroslinealesysecontemplalaposibilidaddegenerarcuadril teros
enalgunasregionesytringulosenotras.
Cada regin se modela mediante un cuadriltero de 8 nodos, que puede utilizarse
como rectngulo (Figura 9), cuadriltero general o tringulo (Figura 10). Para este
cuadrilterosedefineunsistemadecoordenadasnaturales L, n) quetienesuorigen
enelcentrodelmismo,ydonde 1L1 y 1n1 .Unaregintriangularse
modelaalineandodosladosdelcuadrilterogeneral.
GeneracindeMallasde
Figura 9: Regin cuadrangular.

.
GeneracindeMallasde
Figura 8: Un dominio triangular modelado como la unin de
dos regiones triangulares y una cuadrangular.
Figura 10: Regin triangular.
Paradividirunareginenelementos,elPROGAMrealizaelsiguienteproceso:
Separtedelareginnormalizadadefinidaporelsistemadecoordenadas L, n) .
Paraestareginsegenerannfilaspor mcolumnasdenodosequidistantes; nym son
datossuministradosporelusuario.
Cada nodo generado en el sistema L, n) se mapea en el sistema x , y)
empleandolasiguienteinterpolacinisoparamtrica:
x=
i=1
8
d
i
X
i
y=
i =1
8
d
i
Y
i
d
1
=0.251L)1n)L+n+1)
d
2
=0.51L
2
)1n)
d
3
=0.251+L)1n)Ln1)
d
4
=0.51+L)1n
2
)
d
5
=0.251+L)1+n)L+n1)
GeneracindeMallasde
d
6
=0.51L
2
)1+n)
d
7
=0.251L)1+n)nL1)
d
8
=0.51L)1n
2
)
Los vectores X e Y contienen las coordenadas en el plano x , y) de los ochos
nodosquedefinenlaregin,comenzandoporlaesquinainferiorizquierdayprocediendo
ensentidoantihorario.
Unavezobtenidaslascoordenada(x,y)delosnodos,seledebeasignaracadauno
unnmeroenteroparasuidentificacin.Esimportanteaclararqueestanumeracines
global,esdecirqueabarcaatodaslasregiones.Ademslasregionesvecinascomparten
losnodosubicadossobrelafronteracomn,porlotantosedeberealizaruncontrolpara
determinar si los nodos ubicados en las fronteras, han sido numerados previamente,
duranteelprocesamientodelareginvecina.Sielcontrolespositivo,losnodossobrela
frontera analizada conservan la numeracin existente. A continuacin se numeran
secuencialmentelosnodosdelaregin,comenzandoporelubicadoenlascoordenadas
L=1 y n=1 ,yprocediendodeizquierdaaderechaydearribahaciaabajo.Los
nodospreviamentenumeradossesaltean.
Finalmente se definen los elementos de la regin como vectores de tres o cuatro
enteros,segnseantringulosocuadrilteros.Cadavectorcontienelosnmerosdelos
nodosqueformanelelemento.
GeneracindeMallasde
Problema de ejemplo
Parailustrarelprocedimientopresentadoenlaseccinanterior,seusareldominio
triangulardelafigura8,elcualsesubdivideenunaregincuadrilteraydostringulos.
Lascoordenadas(x,y) delosnodosquedefinenlasregionessondatosdeentrada
suministradosporelusuario.Lanumeracindelosmismosesarbitraria.Losnodos4y6
sedesplazanhaciaelnodo5paraobtenerelementosmspequeoscercadelaesquina.
Para la regin 2 se elige una subdivisin de cinco filas y cinco columnas. Esta
seleccinfijaelnmerodefilasenlaregin3encincoyelnmerodecolumnasenla
regin1encinco,yaquelasregionesvecinascompartenlosnodosubicadossobrela
frontera.
Elementosmsgrandesseobtienenenlasregiones1y3colocandoslotresfilasde
nodosen la regin 1, y trescolumnas enlaregin3. La regin3 ser subdivididaen
elementos cuadrangulares, mientras que para las restantes se utilizarn elementos
triangulares.
A continuacin se detalla el procedimiento realizado para la generaci n de los
elementosenlaregin3,definidaporlosnodos1,2,3,18,13,15,16y17;paralasotras
dosregionessesigueunprocesosimilar:
1) Segeneranenlareginnormalizadadefinidaporelsistema L, n) cincofilaspor
trescolumnasdenodos(Figura11).
GeneracindeMallasde
Figura 11: Generacin de
los nodos en la regin
normalizada.
2) Secalculanlascoordenadas(x,y)delosnodos,aplicandoparacadaunolasfrmulas
delainterpolacinisoparamtrica(Figura12).
Figura 12: Resultado de la
interpolacin isoparamtrica.
3) Senumeranlosnodoscomenzandoporelextremosuperiorizquierdoyprocediendo
deizquierdaaderechaydearribahaciaabajo.Losnodosubicadosenlosbordes
comunessonnumeradosporlareginquetengaelmenornmero,esdecirquelos
nodosubicadosenelbordederechofueronnumeradosduranteelprocesamientodela
regin2,ydebensaltearse(Figura13).
GeneracindeMallasde
Figura 13: Numeracin de los nodos en la regin 3. La
secuencia comienza por el nmero 36 porque los
menores a ste fueron asignados en las regiones 1 y 2.
Los valores de la frontera derecha fueron asignados
durante el procesamiento de la regin 2.
4) Finalmenteseobtienenloselementos(Figura14).
GeneracindeMallasde
Figura 14: Elementos generados dentro de la
regin 3.
Unavezprocesadaslastresregiones,secombinanlosresultadosparaformarlamalla
deelementosfinitos(Figura15).
Figura 15: Malla de elementos finitos generada con el
PROGAM.
GeneracindeMallasde
III.DESARROLLODEINGENIERA
GeneracindeMallasde
LANUEVAIMPLEMENTACINDELPROGAM
La versin original del PROGAM slo est disponible en papel, junto con una gran
cantidad de documentacin acerca de su funcionamiento. Por alguna razn que
desconozco,laversindigitaldelprogramaseperdi,yparapodercomenzarconeste
trabajonecesitabaunPROGAMejecutable.
Unaposiblesolucinaesteproblemaconsistaenescanearelcdigofuenteypasarlo
porunOCR.Estohubieratomadomuchotiempo,yaquecomoelOCRnoesperfecto,se
tendra que revisar todo el cdigo para corregir los errores. Adems, el cdigo no es
estructurado y contiene muchas instrucciones goto, lo que dificulta su comprensin y
estudio.
Decid entonces realizar una nueva implementacin en Fortran 90, analizando la
documentacintcnicayelcdigofuenteexistente.Elnuevoprogramameserviracomo
baseparadesarrollarelPROGAMparalelo,yparacompararelrendimientodelasoluci n
paralelaconeldelasecuencial.
Acontinuacindescribirlosaspectosprincipalesdeestanuevaimplementacin.
Laestructuradedatosregion_t
Todalainformacinreferidaaunadeterminadaregindeldominioestcontenidaen
unaestructuradedatos,deltiporegion_t.lacualestdefinidaenelarchivoregion.f90.
GeneracindeMallasde
TYPEregin_t
!Nmeroderegin
INTEGER::num
!Nmerodefilasycolumnasdenodos
INTEGER::n,m
!Tipodeelemento(3=triangular,4=cuadrangular)
INTEGER::elem_type
!Datosdeconectividad
INTEGER::vecinas(4)
!Los8ochonodosquedefinenlaregin
REAL::def_nodes(8,2)
!Coordenadas(x,y)delosnodos
REAL,ALLOCATABLE::node_coords(:,:,:)
!Nmerosdelosnodos
INTEGER,ALLOCATABLE::node_nums(:,:)
!Cadaelementoesunvectorde3o4enteros
INTEGER,ALLOCATABLE::elements(:,:)
ENDTYPEregion_t
Nmeroderegin:Lasregionessenumeranenformasecuencialapartirde1.
Nmerodefilasycolumnas:Definenlacantidaddenodosenlareginydeterminanla
cantidad de elementos: (n1)(m1) elementos cuadrangulares o 2(n1)(m1) elementos
triangulares.
Tipo de elemento: Los nicos elementos admitidos son el tringulo de tres nodos
(elem_type=3)yelcuadradode4nodos(elem_type=4).
Datosdeconectividad:Elvectorvecinascontienelosnmerosdelasregionesvecinas
inferior, derecha, superior e izquierda respectivamente. Un cero en cualquiera de sus
elementosindicaquenohayningunareginenlafronteracorrespondiente.
Definicin de laregin: La matriz def_nodes contiene las coordenadas (x, y) de los
ocho nodos que definen la regin, comenzando por el del extremo inferior izquierdo y
siguiendoensentidoantihorario.
GeneracindeMallasde
Loscamposdescriptoshastaaccontienendatosacercadelageometradelaregin
y deben ser suministrados por el usuario. Los campos que siguen contendrn la
informacindeloselementosgeneradosporelprograma.
Coordenadasdelosnodos: Enlamatriznode_coords seguardarnlascoordenadas
(x,y)delosnodosgenerados.Eltamaodelamatrizseriguala2nm.
Nmeros de los nodos: La matriz node_nums contendr los nmeros enteros
asignadosalosnodosparasuidentificacin.
Elementos:Unelementoestrepresentadoporunvectorquecontienelosnmerosde
losnodosquelodefinen,porlotantoeltamaodelamatrizelements seriguala3*
cantidad_de_elementos 4 * cantidad_de_elementos, segn se trate de tringulos o
cuadrilteros.
Funcionamiento del programa
Para generar una malla de elementos finitos, el PROGAM ejecuta una serie de
funcionesenformasecuencial (Figura16).Estasfuncionesestnimplementadascomo
subrutinasenelarchivoregion.f90,ysonllamadasdesdeelarchivoprogam.f90.
Lecturadelarchivodeentrada:Consisteenlainicializacindelasestructurasdedatos
correspondientesacadaregincon lainformacin contenidaenel archivodeentrada.
Estolorealizalasubrutinaregion_input,quedevuelveunvectordeltiporegion_t,donde
cadaelementocorrespondeaunaregindeldominio.
GeneracindeMallasde
Figura 16: Diagrama de
flujo del PROGAM
secuencial.
Generacin de los nodos en cada regin: La subrutina region_grid calcula las
coordenadas (x,y) delosnodosqueformarnloselementos, aplicandolainterpolacin
isoparamtricapresentadaenelcaptuloanterior.Recibecomoargumentounaestructura
region_t yguardalosresultadosenel lamatriznode_coords. Esllamadaunavezpor
cadaregincontenidaenelvectordevueltoporlasubrutinaregion_input.
Numeracindelosnodos:Lasubrutinaregion_nodenumsnumeralosnodosdentrode
lareginquerecibecomoprimerargumento.Elsegundoparmetro,denominadonstart,
GeneracindeMallasde
indica el primer nmero disponible (recordemos que esta numeracin es global). Si la
reginlimitaconotraidentificadaporunnmerodereginmenor,entoncesalosnodos
ubicados sobre la frontera comn se les coloca los nmeros asignados durante la
numeracindenodosdelareginvecina.Losnmerosdelosnodosseguardanenla
matriznode_nums.
Generacin de los elementos: Esta funcin est implementada en la subrutina
region_elements.Porcadaelementosedefineunvectorde3o4enteros,segnsetrate
detringulosocuadrilteros.Estevectorcontienelosnmerosdelosnodosqueforman
elelemento.Losvectoresdetodosloselementosdelaregi nseagrupanenlamatriz
elements.
Escrituradelarchivodesalida:Lasubrutinaregion_outputescribelosresultadosenun
archivo de texto, de acuerdo al formato requerido por GiD (el programa utilizado para
visualizarlamalla).
GeneracindeMallasde
PARALELIZACINDELPROGAM
Paragenerarunamalladeelementosfinitos,elPROGAMparalelo(PROGAMP)utiliza
un procesador del cluster por cada regin del dominio. Supongamos que tenemos un
dominiocompuestoporcuatroregiones(Figura17).Enestecaso,seejecutarncuatro
procesosPROGAMPensendosnodosdel cluster (Figura18).Cadaprocesogenerar
una malla de elementos finitos dentro de la regin que le fue asignada (Figura 19).
Finalmente,uniendolosresultadosdeloscuatroprocesosobtendremoslamallacompleta
(Figura20).
Figura 17: Dominio compuesto por
cuatro regiones.
GeneracindeMallasde
Figura 18: Para resolver el problema en
paralelo, se necesitan cuatro procesadores.
Figura 19: Cada procesador resuelve una
regin.
GeneracindeMallasde
Figura 20: Finalmente, se
unifican los resultados.
La figura 21 ilustra el diagrama de flujo del PROGAMP. Los bloques en gris
representan funciones que requieren comunicacin entre procesos. Los bloques en
blancorepresentansubrutinasqueutilizandatosdeuna nicaregin,ysufuncionalidad
esindependientedelosotrosprocesos,esporestoquesuimplementaci nnodifierede
laversinsecuencial.Acontinuacindescribirlaimplementacindelosbloquesgrises.
Lecturadelarchivodeentrada
Este bloque est implementado en la subrutina region_input_p. El proceso 0 es el
nicoquetienehabilitadoelcanaldeentradaestndar.Debeleerlosdatosdeentraday
enviarlosalosprocesoscorrespondientes.
La matriz que contiene las coordenadas de los nodos que definen las regiones es
enviada atodoslosprocesosmediantelarutinaMPI_BCAST,elprocesoreceptordebe
determinarculescorrespondenalareginqueletocaprocesar.
Los datos propios de cada regin (nmero de filas, nmero de columnas, etc) son
transmitidosmediantellamadasaMPI_SENDyMPI_RECValprocesocorrespondiente.
GeneracindeMallasde
Figura 21: Diagrama de flujo del PROGAM-P resolviendo un problema de tres regiones.
Las lneas rojas indican el pasaje de mensajes entre procesos. Para no complicar el
grfico, no se muestra la comunicacin entre los procesos 0 y 2.
Numeracindelosnodos
Lasubrutinaregion_nodenums_p asignaunnmeronicoacadanododelaregin
querecibecomoargumento.Elprocesoquesesigueessimilaralseguidoporlarutina
region_nodenums delPROGAMsecuencial.Ladiferenciaestenlamaneraenquese
numeran los nodos ubicados en una frontera entre dos regiones. En el ejemplo de la
GeneracindeMallasde
figura8,elprocesoencargadodelaregin1numeralosnodoscompartidosentrestay
laregin2.Unavezcompletadalanumeracinenvalosnmerosalprocesoencargado
delaregin2medianteunallamadaaMPI_SEND.EsteltimodebellamaraMPI_RECV
para obtener los nmeros de los nodos de su frontera superior, y a MPI_SEND para
enviarlosnmerosdesufronteraizquierdaalprocesoencargadodelaregi n3.
Escrituradelarchivodesalida
Laescrituradelosresultadosestimplementadaenlasubrutinaregion_output_p. La
informacindesalidaseescribeenunnicoarchivodetexto(output.msh),deacuerdoal
formatorequeridoporGiD.Paraestodebenresolversedosproblemasfundamentales:
1. Accesoalarchivo:Todoslosprocesosdebenescribirenelmismoarchivo,porlo
tantostedeberubicarseenunsistemadearchivoscompartido,comoNFS.
2. Sincronizacin:paraquelasalidaseaordenadaelprocesonnopodrcomenzar
aescribirhastaqueel proceson1hayaterminado.Esteproblemaseresuelve
mediante la transmisin de un turno, el cual est inicialmente en posesin del
proceso0.
Elsiguientepseudocdigoilustraelprocedimientopropuesto:
GeneracindeMallasde
IF(my_rank>0)
CALLMPI_RECV(my_rank1,turno)
Abrirarchivo.
Escribirinformacindesalida.
Cerrararchivo.
IF(my_rank<max_rank)
CALLMPI_SEND(my_rank+1,turno)
GeneracindeMallasde
IV.RESULTADOS
GeneracindeMallasde
RENDIMIENTO
ElclusterdelLAPIC
El cluster enelqueserealizaronlaspruebasestcompuestopor13computadoras
conprocesadorIntel PentiumIV3GHzHT,1GBdememoriaRAMysistemaoperativo
GNU/Linux,interconectadasmedianteunaredGigabitEthernet.
La tecnologa Hyper Threading (HT) de los procesadores Intel permite ejecutar en
formaparaleladosprocesosenunmismoprocesador.Porlotantopodemoscorrerenel
clusterhasta26procesossimultneamente.
ParalacomunicacinentrelosprocesosseutilizlabibliotecaMPICH2,unadelas
implementacionesexistentesdelestndarMPI2.0.ElPROGAMyelPROGAMPfueron
compiladosconelIntelFortranCompiler9.0.
ElperfilNACA23012
Con el fin de ilustrar una aplicacin ms compleja, que suele ser de inters en
problemasdefluidos,escogelperfilNACA23012paramostrarelfuncionamientoylas
prestacionesdelPROGAM,ycompararelrendimientodelaversi nparalelaconeldela
versinsecuencial.
Comoesbienconocidoenelcasodefluidos,esimportantemodelaradecuadamente
lacapalmite,paralocualsedeberefinarconvenientementelamallaalrededordelperfil,
esdecirquealrededordelmismosenecesitanelementosmuypequeos.
En la figura 22 se muestra una malla simple de 1066 elementos, modelada con el
PROGAMP a partir de un dominio compuesto por 20 regiones (se ejecutaron 20
procesos).
GeneracindeMallasde
Figura 22: Malla compuesta por 1066 elementos.
Lafigura23muestraunamallacompuestapor11438elementos,generadaapartirdel
mismodominioquelaanterior.
Figura 23: Malla compuesta por 11438 elementos.
GeneracindeMallasde
Speedup
Sedenominaspeedup alcocienteentreel tiempoquetardael programasecuencial
T
u
) y el tiempo que tarda el programa paralelo T
) en resolver un mismo
problema.Elspeedupdependedelnmerodeprocesadores(p)utilizadospararesolverel
problemaenparaleloydeltamaodelproblema(n).Ennuestrocasonserigualala
cantidaddeelementosagenerar.
S n , p)=
T
u
n)
T
n , p)
; 0S n , p)p
Eficiencia
Laeficienciadelprogramaparalelosedeterminadividiendoel speedupporelnmero
deprocesadoresutilizados.
E n, p)=
S n, p)
p
=
T
u
n)
pT
n, p)
; 0E n , p)1
Si laeficiencia alcanzael 100%(E= 1yS=p) sedicequeel programapresenta
speedup lineal, ya que S ser funcin lineal del tamao del problema n. Esta es una
situacinidealqueenlaprcticanoseconsigue,debidoalacantidaddetrabajorealizado
porelprogramaparaleloquenoesrealizadoporelprogramasecuencial.Estoincluyeel
costodecomunicacin(determinadoporlalatenciayel anchodebandadelared),el
tiempoocioso(unprocesoesperandoqueotroleenvealgnvalornecesarioparapoder
continuar su ejecucin), y los clculos extra necesarios para resolver el problema en
paralelo.
RendimientodelPROGAMP
GeneracindeMallasde
ParaevaluarelrendimientodelPROGAMPmedlostiemposquetardanlasversiones
paralela y secuencial en calcular mallas de elementos finitos alrededor del perfil
NACA23012, comenzando con un nmero pequeo de elementos, e incrementando
geomtricamente este valor hasta alcanzar los 14 millones de elementos
aproximadamente. Esta prueba est programada en los fuentes test.f90 de ambas
implementaciones,pudiendousarsecualquierdominiopararealizarla.Almedireltiempo
deejecucinnosetienenencuentalasoperacionesdeentradaysalida.
Enlafigura24semuestraungrficoconlosresultados,hechoconGnuplot.Tambin
semuestranalgunosvaloresaproximadosdespeedupyeficiencia(Tabla1).
Enelgrficoseobservaquelasolucinparaleladisminuyenotablementeeltiempode
ejecucin, esto tambin se percibe cuando uno se encuentra frente a la consola del
sistemaejecutandoelprograma.
Los valores de speedup obtenidos permiten afirmar que el programa paralelo se
ejecutaunas13vecesmsrpidoqueelsecuencial,loqueequivaleaunaeficienciadel
65%aproximadamente.
GeneracindeMallasde
Figura 24: Comparacin entre los tiempos que tardan el PROGAM y el PROGAM-P en
resolver el perfil NACA23012 a medida que se incrementa la cantidad de elementos.
n S(n,20) E(n,20)
2 millones 13 0,65
6 millones 16,6 0,83
10 millones 13,6 0,68
14 millones 12 0,60
Tabla 1: Valores aproximados de speedup y eficiencia obtenidos mediante la observacin
del grfico anterior.
GeneracindeMallasde
V.CONCLUSIONES
GeneracindeMallasde
CONCLUSIONES
Losclustersbeowulf representanunaformasumamenteeconmicade implementar
unentornoparalelo,yaqueestnconstituidosporhardwaredisponibleenelmercadode
computadorasdeescritorioysoftwarelibre.LosresultadosobtenidosconelPROGAMP
muestranquesedisminuyenotablementeeltiempodeejecucinalcorrerelprogramaen
unclusterdeestetipo.
Sin embargo, a la hora de disear un algoritmo para resolver un determinado
problema, es necesario analizar qu partes del mismo se pueden ejecutar en forma
concurrenteyculesno,yrealizarunaestimacindelspeedup.Estamedidanosdirqu
tantomsrpidoseejecutarlaversinparalelaquelasecuencial(enalgunoscasoses
posible que la solucin paralela sea ms lenta), y as poder decidir se conviene o no
implementarunasolucinparalela.
El PROGAMP cuenta con una limitacin muy seria que deber ser resuelta en el
futuro,yesquesecreaunprocesoporcadaregindeldominio,sinimportarlacantidad
deelementosquesedebangenerarencadaunadeellas.Estohacequeelbalancede
carga entrelos nodosdel cluster nosea el ptimo. Adems, enel caso de tenerms
regiones que procesadores, la biblioteca MPICH les asignar a algunos procesadores
msdeunproceso,desbalanceandoanmslacarga.
GeneracindeMallasde
VI.REFERENCIAS
GeneracindeMallasde
REFERENCIAS
1. Fortran,http://es.wikipedia.org/wiki/Fortran
2. Garca Garino, Carlos y Ortiz Andino, C., 1984, Descripcin del Programa de
Generacin Automtica de Mallas (PROGAM). Nota Tcnica N 21, IMPSA,
Argentina.
3. GiDThepersonalpreandpostprocessor,http://gid.cimne.upc.es
4. gnuplothompage,http://www.gnuplot.info
5. IntelFortranCompilerforLinux,
http://www.intel.com/support/performancetools/fortran/linux/
6. Len,OscarA.yGarcaGarino,Carlos,ProgramacinParalelaconMPI
7. MessagePassingInterfaceForum,http://www.mpiforum.org
8. MPICH2,http://wwwunix.mcs.anl.gov/mpi/mpich2/
9. RocksClusterDistribution,http://www.rocksclusters.org
10. Segerlind,L.J.,1976,AppliedFiniteElementAnalysis,Wiley,EstadosUnidos.
11. TheBeowulfClusterSite,http://www.beowulf.org
GeneracindeMallasde
VII.CDIGOFUENTE
GeneracindeMallasde
PROGAMSECUENCIAL
progam.f90
1 ! $Id: progam.f90,v 1.2 2006-07-16 23:07:26 emiliano Exp $
2 ! PROGAM - Programa de Generacin Automtica de Mallas
3
4 PROGRAM progam_s
5 USE region_mod
6 IMPLICIT NONE
7
8 TYPE(region_t), ALLOCATABLE, TARGET :: regions(:)
9 INTEGER :: i, n_regions, nstart
10
11 ! Procesamiento de la entrada de datos
12 CALL region_input(regions)
13 n_regions = SIZE(regions)
14
15 ! Divide cada regin en elementos cuadrangulares
16 DO i=1, n_regions
17 CALL region_grid(regions(i))
18 END DO
19
20 ! Asigna un nmero nico a cada nodo
21 nstart = 1
23 CALL region_nodenums(regions(i), nstart, regions)
24 END DO
25
26 ! Genera los elementos
28 CALL region_elements(regions(i))
29 END DO
30
31 ! Salida para GiD
32 CALL region_output(regions)
33
34 END PROGRAM progam_s
region.f90
1 ! $Id: region.f90,v 1.2 2006-07-16 21:51:41 emiliano Exp $
3
4 MODULE region_mod
5 !DEC$ REAL:8
6 IMPLICIT NONE
7
8 TYPE region_t
9 INTEGER :: num ! nmero de regin
10 INTEGER :: n, m ! cantidad de filas y columnas
11 INTEGER :: elem_type ! 3=tringulo, 4=cuadrado
12 INTEGER :: vecinas(4) ! datos de conectividad
13 REAL :: def_nodes(8,2) ! los 8 nodos que definen la regin
14 REAL, ALLOCATABLE :: node_coords(:,:,:) ! coordenadas de los nodos
15 INTEGER, ALLOCATABLE :: node_nums(:,:) ! nmeros de los nodos
16 INTEGER, ALLOCATABLE :: elements(:,:) ! cada elemento es un vector de 3 o 4 enteros
17 END TYPE region_t
18
19 CONTAINS
21 SUBROUTINE region_input(regions)
22 TYPE(region_t), TARGET, ALLOCATABLE, INTENT(OUT) :: regions(:)
23 REAL, ALLOCATABLE :: input_nodes(:,:)
24 INTEGER :: n_regions, n_input_nodes
25 INTEGER :: node_nums(8)
GeneracindeMallasde
26 INTEGER :: node_num, i
27
28 READ(*,*) n_regions, n_input_nodes
29 ALLOCATE(regions(n_regions), input_nodes(n_input_nodes,2))
30
31 DO i=1, n_input_nodes
32 READ(*,*) node_num, input_nodes(i,:)
33 END DO
34
36 READ(*,*) regions(i)%n,regions(i)%m,regions(i)%elem_type,regions(i)%vecinas,node_nums
37 regions(i)%num = i
38 regions(i)%def_nodes = input_nodes(node_nums,:)
39 END DO
40 END SUBROUTINE region_input
41
42 ! Divide la regin en (n-1)*(m-1) elementos cuadrangulares.
43 SUBROUTINE region_grid(this)
44 TYPE(region_t), INTENT(INOUT) :: this
45 INTEGER :: i, j
46 REAL :: pun(8) ! funciones de forma
47 REAL :: eta, si ! coordenadas normalizadas
48 REAL :: deta, dsi ! incrementos de eta y si
49
50 ALLOCATE(this%node_coords(this%n,this%m,2))
51 ALLOCATE(this%node_nums(this%n,this%m))
52
53 deta = 2./(this%n-1)
54 dsi = 2./(this%m-1)
55 DO i=1, this%n
56 eta = 1 - (i-1)*deta
57 DO j=1, this%m
58 si = -1 + (j-1)*dsi
59 pun(1) = -0.25 * (1-si) * (1-eta) * (si+eta+1)
60 pun(2) = 0.5 * (1-si**2) * (1-eta)
61 pun(3) = 0.25 * (1+si) * (1-eta) * (si-eta-1)
62 pun(4) = 0.5 * (1+si) * (1-eta**2)
63 pun(5) = 0.25 * (1+si) * (1+eta) * (si+eta-1)
64 pun(6) = 0.5 * (1-si**2) * (1+eta)
65 pun(7) = 0.25 * (1-si) * (1+eta) * (eta-si-1)
66 pun(8) = 0.5 * (1-si) * (1 - eta**2)
67 this%node_coords(i,j,1) = SUM(this%def_nodes(:,1) * pun)
69 END DO
70 END DO
71 END SUBROUTINE region_grid
72
73 ! Numera en forma global los nodos de la regin, teniendo en cuenta los que
74 ! ya han sido numerados por otras regiones. La variable nstart contiene el
75 ! primer nmero de la secuencia, y devuelve el primer nmero de la siguiente
76 ! region.
77 SUBROUTINE region_nodenums(this, nstart, regions)
78 TYPE(region_t), TARGET, INTENT(INOUT) :: this
79 INTEGER, INTENT(INOUT) :: nstart
80 TYPE(region_t), INTENT(IN) :: regions(:)
81 INTEGER :: i, j, istart, jstart, iend, jend
82 INTEGER, POINTER :: bound_nums(:)
83 REAL :: chk_node(2), recv_node(2)
84
85 istart=1
86 jstart=1
87 iend=this%n
88 jend=this%m
89
90 ! Verifica si los nodos de las fronteras son numerados por otra regin
91 IF (this%vecinas(1)<this%num .AND. this%vecinas(1)/=0) iend=iend-1
92 IF (this%vecinas(2)<this%num .AND. this%vecinas(2)/=0) jend=jend-1
93 IF (this%vecinas(3)<this%num .AND. this%vecinas(3)/=0) istart=istart+1
94 IF (this%vecinas(4)<this%num .AND. this%vecinas(4)/=0) jstart=jstart+1
95
96 ! Numera los nodos
97 DO i=istart, iend
GeneracindeMallasde
98 DO j=jstart, jend
99 this%node_nums(i,j) = nstart
100 nstart = nstart+1
101 END DO
102 END DO
103
104 ! Numera las fronteras que no han sido numeradas
105 DO i=1, 4
106 SELECT CASE(i)
107 CASE(1)
108 bound_nums => this%node_nums(this%n,:) ! abajo
109 chk_node = this%node_coords(this%n,1,:)
110 CASE(2)
111 bound_nums => this%node_nums(:,this%m) ! derecha
112 chk_node = this%node_coords(1,this%m,:)
113 CASE(3)
114 bound_nums => this%node_nums(1,:) ! arriba
115 chk_node = this%node_coords(1,1,:)
116 CASE(4)
117 bound_nums => this%node_nums(:,1) ! izquierda
119 END SELECT
120
121 IF (this%vecinas(i)<this%num .AND. this%vecinas(i)/=0) THEN
122 CALL region_bound(regions(this%vecinas(i)), this%num, bound_nums, recv_node)
123 IF (ANY(chk_node/=recv_node)) CALL invertir(bound_nums)
124 END IF
125 END DO
126 END SUBROUTINE region_nodenums
127
128 ! Devuelve los nmeros de nodos que estn en la frontera con una regin especfica.
129 SUBROUTINE region_bound(this, vecina, bound_nums, chk_node)
130 TYPE(region_t), INTENT(IN) :: this ! regin origen
131 INTEGER, INTENT(IN) :: vecina ! regin destino
132 INTEGER, INTENT(OUT) :: bound_nums(:) ! vector en el que se devuelven los nmeros
133 REAL, INTENT(OUT) :: chk_node(2) ! coordenadas de uno de los extremos
134
135 ! No uso select case porque require expresiones constantes.
136 IF (vecina==this%vecinas(1)) THEN
137 bound_nums = this%node_nums(this%n,:)
139 ELSE IF (vecina==this%vecinas(2)) THEN
140 bound_nums = this%node_nums(:,this%m)
143 bound_nums = this%node_nums(1,:)
146 bound_nums = this%node_nums(:,1)
148 END IF
149 END SUBROUTINE region_bound
150
151 ! Invierte el orden de los elementos en el vector.
152 SUBROUTINE invertir(vector)
153 INTEGER, INTENT(INOUT) :: vector(:)
154 INTEGER :: aux(SIZE(vector))
155 INTEGER :: i, n
156
157 n = SIZE(vector)
158 DO i=1, n
159 aux(n-i+1) = vector(i)
160 END DO
161 vector = aux
162 END SUBROUTINE invertir
163
164 ! Genera elementos triangulares (dividiendo los cuadrados segn la diagonal ms
165 ! corta del elemento (1,1)) o cuadrangulares. Cada elemento es un vector formado
166 ! por los nmeros de los nodos que lo definen.
167 SUBROUTINE region_elements(this)
169 INTEGER :: i, j, k
GeneracindeMallasde
170 REAL :: diag1, diag2
171
172 IF (this%elem_type == 3) THEN ! elementos triangulares
173 ALLOCATE(this%elements((this%n-1)*(this%m-1)*2, 3))
174 k = 1
175 diag1 = SQRT((this%node_coords(1,1,1)-this%node_coords(2,2,1))**2 &
176 + (this%node_coords(1,1,2)-this%node_coords(2,2,2))**2)
179
180 IF (diag1 < diag2) THEN
181 DO i=1, this%n-1
182 DO j=1, this%m-1
183 this%elements(k,1) = this%node_nums(i,j)
184 this%elements(k,2) = this%node_nums(i+1,j)
185 this%elements(k,3) = this%node_nums(i+1,j+1)
186 k = k+1
189 this%elements(k,3) = this%node_nums(i,j+1)
190 k = k+1
191 END DO
192 END DO
193 ELSE
199 k = k+1
203 k = k+1
204 END DO
205 END DO
206 END IF
207
208 ELSE IF (this%elem_type == 4) THEN ! elementos cuadrangulares
209 ALLOCATE(this%elements((this%n-1)*(this%m-1), 4))
210 k = 1
217 k = k+1
218 END DO
219 END DO
220 END IF
221 END SUBROUTINE region_elements
222
224 SUBROUTINE region_output(regions)
225 TYPE(region_t), INTENT(IN) :: regions(:)
226 INTEGER :: i, j, k, elem_num, node_num
227
228 elem_num = 1
229 node_num = 0
230 OPEN(UNIT=1, FILE='output.msh')
231
232 DO k=1, SIZE(regions)
233 ! Cabecera
234 IF (regions(k)%elem_type==3) THEN
235 WRITE(1,*) 'MESH dimension 2 ElemType Triangle Nnode 3'
236 ELSE IF (regions(k)%elem_type==4) THEN
237 WRITE(1,*) 'MESH dimension 2 ElemType Quadrilateral Nnode 4'
238 END IF
239
240 ! Coordenadas de los nodos
241 WRITE(1,*) 'coordinates'
GeneracindeMallasde
242 WRITE(1,*) '# num x y'
243 DO i=1, regions(k)%n
244 DO j=1, regions(k)%m
245 IF (regions(k)%node_nums(i,j)>node_num) THEN
246 node_num = regions(k)%node_nums(i,j)
247 WRITE(1,*) node_num, regions(k)%node_coords(i,j,:)
248 END IF
249 END DO
250 END DO
251 WRITE(1,*) 'end coordinates'
252
253 ! Elementos
254 WRITE(1,*) 'elements'
255 WRITE(1,*) '# num nodo1 nodo2 nodo3 nodo4'
256 DO i=1, SIZE(regions(k)%elements, DIM=1)
257 WRITE(1,*) elem_num, regions(k)%elements(i,:)
258 elem_num = elem_num+1
259 END DO
260 WRITE(1,*) 'end elements'
261 WRITE(1,*)
262 END DO
263 END SUBROUTINE region_output
264 END MODULE region_mod
test.f90
1 ! $Id: test.f90,v 1.1.1.1 2006-07-16 21:18:46 emiliano Exp $
3
4 ! Esta prueba genera sucesivamente mallas de elementos finitos,
5 ! aumentando la cantidad de elementos geomtricamente. Para cada
6 ! malla se toma el tiempo de clculo, sin considerar la entrada
7 ! ni la salida de datos.
8
9 PROGRAM progam_s_test
10 USE region_mod
11 IMPLICIT NONE
12
13 TYPE(region_t), ALLOCATABLE, TARGET :: regions(:)
14 INTEGER :: i, n_regions, nstart
15 REAL :: ti, tf
16 INTEGER :: ierr, k
17 INTEGER, ALLOCATABLE :: n_init(:), m_init(:)
18
20 CALL region_input(regions)
21 n_regions = SIZE(regions)
22
23 ALLOCATE(n_init(n_regions), m_init(n_regions))
24 n_init = regions%n
25 m_init = regions%m
26
27 DO k=1, 100
28 regions%n = n_init*k
29 regions%m = m_init*k
30
31 CALL CPU_TIME(ti)
32 ! Divide cada regin en elementos cuadrangulares
34 CALL region_grid(regions(i))
35 END DO
36
37 ! Asigna un nmero nico a cada nodo
38 nstart = 1
40 CALL region_nodenums(regions(i), nstart, regions)
41 END DO
42
43 ! Genera los elementos
GeneracindeMallasde
45 CALL region_elements(regions(i))
46 END DO
47 CALL CPU_TIME(tf)
48
49 WRITE(*,*) DOT_PRODUCT(regions%n, regions%m), tf-ti
51 DEALLOCATE(regions(i)%node_coords)
52 DEALLOCATE(regions(i)%node_nums)
53 DEALLOCATE(regions(i)%elements)
54 END DO
55 END DO
56
57 END PROGRAM progam_s_test
GeneracindeMallasde
PROGAMPARALELO
progam.f90
1 ! $Id: progam.f90,v 1.2 2006-07-17 00:52:06 emiliano Exp $
2 ! PROGAM-P - Programa de Generacin Automtica de Mallas en Paralelo
3
4 PROGRAM progam_p
5 !DEC$ REAL:8
6 USE region_mod
7 IMPLICIT NONE
8
9 TYPE(region_t) :: region_local
10 INTEGER :: ierr
11
12 CALL MPI_INIT(ierr)
13
14 CALL region_init_mod() ! Inicializacin
15 CALL region_input_p(region_local) ! Entrada de datos
16 CALL region_grid(region_local) ! Creacin de los nodos interiores
17 CALL region_nodenums_p(region_local) ! Numeracin de los nodos
18 CALL region_elements(region_local) ! Creacin de los elementos
19 CALL region_output_p(region_local) ! Salida para GiD
20
21 CALL MPI_FINALIZE(ierr)
22
23 END PROGRAM progam_p
region.f90
1 ! $Id: region.f90,v 1.2 2006-07-17 00:52:06 emiliano Exp $
2 ! PROGAM-P(Programa de Generacin Automtica de Mallas en Paralelo)
3
4 MODULE region_mod
5 !DEC$ REAL:8
6 IMPLICIT NONE
7 INCLUDE 'mpif.h'
8
9 TYPE region_t
10 INTEGER :: num ! nmero de regin
11 INTEGER :: n, m ! cantidad de filas y columnas
12 INTEGER :: elem_type ! 3=tringulo, 4=cuadrado
13 INTEGER :: vecinas(4) ! datos de conectividad
14 REAL :: def_nodes(8,2) ! los 8 nodos que definen la regin
15 REAL, ALLOCATABLE :: node_coords(:,:,:) ! coordenadas de los nodos
16 INTEGER, ALLOCATABLE :: node_nums(:,:) ! nmeros de los nodos
17 INTEGER, ALLOCATABLE :: elements(:,:) ! cada elemento es un vector de 3 o 4 enteros
18 END TYPE region_t
19
20 INTEGER, PRIVATE :: my_rank, p, status(MPI_STATUS_SIZE), ierr
21
22 CONTAINS
23 ! Inicializacin
24 SUBROUTINE region_init_mod()
25 CALL MPI_COMM_RANK(MPI_COMM_WORLD, my_rank, ierr)
26 CALL MPI_COMM_SIZE(MPI_COMM_WORLD, p, ierr)
27 END SUBROUTINE region_init_mod
28
30 SUBROUTINE region_input_p(this)
31 TYPE(region_t), INTENT(OUT) :: this
32 INTEGER :: i
33 REAL, ALLOCATABLE :: input_nodes(:,:)
34 INTEGER :: n_regions, n_input_nodes
35 INTEGER :: n, m, elem_type, node_num
GeneracindeMallasde
36 INTEGER :: vecinas(4)
37 INTEGER :: node_nums(8)
38
39 IF (my_rank == 0) THEN
40 READ(*,*) n_regions, n_input_nodes
41 IF (n_regions /= p) THEN
42 WRITE(*,*) 'El nmero de procesos es distinto del nmero de regiones.'
43 CALL MPI_ABORT(MPI_COMM_WORLD, 1, ierr)
44 ENDIF
45 ENDIF
46
47 CALL MPI_BCAST(n_regions, 1, MPI_INTEGER, 0, MPI_COMM_WORLD, ierr)
48 CALL MPI_BCAST(n_input_nodes, 1, MPI_INTEGER, 0, MPI_COMM_WORLD, ierr)
49 ALLOCATE(input_nodes(n_input_nodes,2))
50
51 ! Lectura de los nodos y sus coordenadas
53 DO i=1, n_input_nodes
54 READ(*,*) node_num, input_nodes(i,:)
55 END DO
56 END IF
57
58 ! Los nodos se envan a todos los procesos, sin importar cules necesiten.
59 CALL MPI_BCAST(input_nodes, SIZE(input_nodes), MPI_REAL8, 0, MPI_COMM_WORLD, ierr)
60
62 ! El proceso 0 se queda con la primera regin.
63 READ(*,*) this%n, this%m, this%elem_type, this%vecinas, node_nums
64 this%def_nodes = input_nodes(node_nums,:)
65
66 ! Lee los datos de las regiones restantes y los enva al proceso
67 ! correspondiente.
69 READ(*,*) n, m, elem_type, vecinas, node_nums
70 CALL MPI_SEND(n, 1, MPI_INTEGER, i-1, 0, MPI_COMM_WORLD, ierr)
71 CALL MPI_SEND(m, 1, MPI_INTEGER, i-1, 0, MPI_COMM_WORLD, ierr)
72 CALL MPI_SEND(elem_type, 1, MPI_INTEGER, i-1, 0, MPI_COMM_WORLD, ierr)
73 CALL MPI_SEND(vecinas, 4, MPI_INTEGER, i-1, 0, MPI_COMM_WORLD, ierr)
74 CALL MPI_SEND(node_nums, 8, MPI_INTEGER, i-1, 0, MPI_COMM_WORLD, ierr)
75 END DO
76
77 ELSE
78 ! Recibe los datos enviados por el proceso 0.
79 CALL MPI_RECV(this%n, 1, MPI_INTEGER, 0, 0, MPI_COMM_WORLD, status, ierr)
80 CALL MPI_RECV(this%m, 1, MPI_INTEGER, 0, 0, MPI_COMM_WORLD, status, ierr)
81 CALL MPI_RECV(this%elem_type, 1, MPI_INTEGER, 0, 0, MPI_COMM_WORLD, status, ierr)
82 CALL MPI_RECV(this%vecinas, 4, MPI_INTEGER, 0, 0, MPI_COMM_WORLD, status, ierr)
83 CALL MPI_RECV(node_nums, 8, MPI_INTEGER, 0, 0, MPI_COMM_WORLD, status, ierr)
84 this%def_nodes = input_nodes(node_nums,:)
85 END IF
86
87 this%num = my_rank + 1
88
89 END SUBROUTINE region_input_p
90
91 ! Divide la regin en (n-1)*(m-1) elementos cuadrangulares.
92 SUBROUTINE region_grid(this)
94 INTEGER :: i, j
95 REAL :: pun(8) ! funciones de forma
96 REAL :: eta, si ! coordenadas normalizadas
97 REAL :: deta, dsi ! incrementos de eta y si
98
99 ALLOCATE(this%node_coords(this%n,this%m,2))
100 ALLOCATE(this%node_nums(this%n,this%m))
101
102 deta = 2./(this%n-1)
103 dsi = 2./(this%m-1)
104 DO i=1, this%n
105 eta = 1 - (i-1)*deta
106 DO j=1, this%m
107 si = -1 + (j-1)*dsi
GeneracindeMallasde
108 pun(1) = -0.25 * (1-si) * (1-eta) * (si+eta+1)
109 pun(2) = 0.5 * (1-si**2) * (1-eta)
110 pun(3) = 0.25 * (1+si) * (1-eta) * (si-eta-1)
111 pun(4) = 0.5 * (1+si) * (1-eta**2)
112 pun(5) = 0.25 * (1+si) * (1+eta) * (si+eta-1)
113 pun(6) = 0.5 * (1-si**2) * (1+eta)
114 pun(7) = 0.25 * (1-si) * (1+eta) * (eta-si-1)
115 pun(8) = 0.5 * (1-si) * (1 - eta**2)
118 END DO
119 END DO
120 END SUBROUTINE region_grid
121
122 ! Numera en forma global los nodos de la regin, teniendo en cuenta los que
123 ! ya han sido numerados por otras regiones.
124 SUBROUTINE region_nodenums_p(this)
125 TYPE(region_t), INTENT(INOUT), TARGET :: this
126 INTEGER :: i, j, istart, jstart, iend, jend
127 INTEGER :: nstart ! La numeracin comienza a partir de este nmero.
128 INTEGER :: nend ! Este valor se enva a la siguiente regin.
129 INTEGER :: ranks(4) ! Ranks de las regiones vecinas.
130 INTEGER, POINTER :: bound_nums(:)
131 REAL :: chk_node(2), recv_node(2)
132
133 nstart = 1
134 istart = 1
135 jstart = 1
136 iend = this%n
137 jend = this%m
138
139 ! Verifica si los nodos de las fronteras son numerados por otra regin.
140 IF (this%vecinas(1)<this%num .AND. this%vecinas(1)/=0) iend=iend-1
141 IF (this%vecinas(2)<this%num .AND. this%vecinas(2)/=0) jend=jend-1
142 IF (this%vecinas(3)<this%num .AND. this%vecinas(3)/=0) istart=istart+1
143 IF (this%vecinas(4)<this%num .AND. this%vecinas(4)/=0) jstart=jstart+1
144
145 ! Obtiene el valor nstart
146 IF (my_rank>0) CALL MPI_RECV(nstart, 1, MPI_INTEGER, my_rank-1, 0, MPI_COMM_WORLD,
status, ierr)
147 nend = nstart + (iend-istart+1) * (jend-jstart+1)
148 IF (my_rank<p-1) CALL MPI_SEND(nend, 1, MPI_INTEGER, my_rank+1, 0, MPI_COMM_WORLD, ierr)
149
150 ! Numera los nodos
151 DO i=istart, iend
152 DO j=jstart, jend
153 this%node_nums(i,j) = nstart
154 nstart = nstart+1
155 END DO
156 END DO
157
158 ! Recibe los nodos de las fronteras numeradas por una regin vecina.
159 ! El chk_node es para verificar que el vector recibido est en el orden
160 ! correcto. Los mpi_recv se hacen antes que los mpi_send para contemplar
161 ! el caso de que un nodo ubicado en una esquina, sea numerado por una
162 ! regin vecina y deba ser enviado a otra regin vecina.
163 ranks = this%vecinas - 1
164 DO i=1, 4
165 SELECT CASE(i)
166 CASE(1)
169 CASE(2)
172 CASE(3)
175 CASE(4)
178 END SELECT
GeneracindeMallasde
179
180 IF (this%vecinas(i)<this%num .AND. this%vecinas(i)/=0) THEN
181 CALL MPI_RECV(bound_nums, SIZE(bound_nums), MPI_INTEGER, ranks(i), 0,
MPI_COMM_WORLD, status, ierr)
182 CALL MPI_RECV(recv_node, 2, MPI_REAL8, ranks(i), 1, MPI_COMM_WORLD, status, ierr)
183 IF (ANY(chk_node/=recv_node)) CALL invertir(bound_nums)
184 END IF
185 END DO
186
187 ! Enva los nmeros de las fronteras a las regiones vecinas que tengan mayor
188 ! nmero de regin.
189 DO i=1, 4
190 SELECT CASE(i)
191 CASE(1)
194 CASE(2)
197 CASE(3)
200 CASE(4)
203 END SELECT
204
205 IF (this%vecinas(i)>this%num) THEN
206 CALL MPI_SEND(bound_nums, SIZE(bound_nums), MPI_INTEGER, ranks(i), 0,
MPI_COMM_WORLD, ierr)
207 CALL MPI_SEND(chk_node, 2, MPI_REAL8, ranks(i), 1, MPI_COMM_WORLD, ierr)
208 END IF
209 END DO
210 END SUBROUTINE region_nodenums_p
211
212 ! Invierte el orden de los elementos en el vector.
213 SUBROUTINE invertir(vector)
214 INTEGER, INTENT(INOUT) :: vector(:)
215 INTEGER :: aux(SIZE(vector))
216 INTEGER :: i, n
217
218 n = SIZE(vector)
219 DO i=1, n
220 aux(n-i+1) = vector(i)
221 END DO
222 vector = aux
223 END SUBROUTINE invertir
224
225 ! Genera elementos triangulares (dividiendo los cuadrados segn la diagonal ms
226 ! corta del elemento (1,1)) o cuadrangulares. Cada elemento es un vector formado
227 ! por los nmeros de los nodos que lo definen.
228 SUBROUTINE region_elements(this)
230 INTEGER :: i, j, k
231 REAL :: diag1, diag2
232
233 IF (this%elem_type == 3) THEN ! elementos triangulares
234 ALLOCATE(this%elements((this%n-1)*(this%m-1)*2, 3))
235 k = 1
240
241 IF (diag1 < diag2) THEN
247 k = k+1
GeneracindeMallasde
251 k = k+1
252 END DO
253 END DO
254 ELSE
260 k = k+1
264 k = k+1
265 END DO
266 END DO
267 END IF
268
269 ELSE IF (this%elem_type == 4) THEN ! elementos cuadrangulares
270 ALLOCATE(this%elements((this%n-1)*(this%m-1), 4))
271 k = 1
278 k = k+1
279 END DO
280 END DO
281 END IF
282 END SUBROUTINE region_elements
283
285 SUBROUTINE region_output_p(this)
286 TYPE(region_t), INTENT(IN) :: this
287 INTEGER :: i, j, elem_num, node_num
288
289 IF (my_rank>0) THEN
290 CALL MPI_RECV(elem_num, 1, MPI_INTEGER, my_rank-1, 0, MPI_COMM_WORLD, status, ierr)
291 CALL MPI_RECV(node_num, 1, MPI_INTEGER, my_rank-1, 0, MPI_COMM_WORLD, status, ierr)
292 OPEN(UNIT=1, FILE="output.msh", ACTION='WRITE', POSITION='APPEND', STATUS='OLD')
293 ELSE
294 elem_num = 1
295 node_num = 0
296 OPEN(UNIT=1, FILE="output.msh", ACTION='WRITE', STATUS='REPLACE')
297 END IF
298
299
300 ! Cabecera
301 IF (this%elem_type==3) THEN
302 WRITE(1,*) 'MESH dimension 2 ElemType Triangle Nnode 3'
303 ELSE IF (this%elem_type==4) THEN
304 WRITE(1,*) 'MESH dimension 2 ElemType Quadrilateral Nnode 4'
305 END IF
306
307 ! Coordenadas de los nodos
308 WRITE(1,*) 'coordinates'
309 WRITE(1,*) '# num x y'
310 DO i=1, this%n
311 DO j=1, this%m
312 IF (this%node_nums(i,j)>node_num) THEN
313 node_num = this%node_nums(i,j)
314 WRITE(1,*) node_num, this%node_coords(i,j,:)
315 END IF
316 END DO
317 END DO
318 WRITE(1,*) 'end coordinates'
319
320 ! Elementos
GeneracindeMallasde
321 WRITE(1,*) 'elements'
322 WRITE(1,*) '# num nodo1 nodo2 nodo3 nodo4'
323 DO i=1, SIZE(this%elements, DIM=1)
324 WRITE(1,*) elem_num, this%elements(i,:)
325 elem_num = elem_num+1
326 END DO
327 WRITE(1,*) 'end elements'
328 CLOSE(1)
329
330 IF (my_rank<p-1) THEN
331 CALL MPI_SEND(elem_num, 1, MPI_INTEGER, my_rank+1, 0, MPI_COMM_WORLD, ierr)
332 CALL MPI_SEND(node_num, 1, MPI_INTEGER, my_rank+1, 0, MPI_COMM_WORLD, ierr)
333 END IF
334 END SUBROUTINE region_output_p
335ENDMODULEregion_mod
test.f90
1 ! $Id: test.f90,v 1.2 2006-07-17 00:52:06 emiliano Exp $
2 ! PROGAM-P - Programa de Generacin Automtica de Mallas en Paralelo
3
4 PROGRAM progam_p_test
5 !DEC$ REAL:8
6 USE region_mod
7 IMPLICIT NONE
8
9 TYPE(region_t) :: region_local
10 INTEGER :: my_rank, p, ierr
11 REAL :: ti, tf
12 INTEGER :: n_local, m_local ! Valores iniciales de n y m
13 INTEGER :: x ! Factor de multiplicacin de n y m
14 INTEGER, ALLOCATABLE :: n(:), m(:) ! Para calcular el nmero total de nodos
15
16 CALL MPI_INIT(ierr)
17 CALL MPI_COMM_RANK(MPI_COMM_WORLD, my_rank, ierr)
18 CALL MPI_COMM_SIZE(MPI_COMM_WORLD, p, ierr)
19
20 CALL region_init_mod() ! Inicializacin
21 CALL region_input_p(region_local) ! Entrada de datos
22
23 n_local = region_local%n
24 m_local = region_local%m
25 IF (my_rank==0) ALLOCATE(n(p), m(p))
26 CALL MPI_GATHER(n_local, 1, MPI_INTEGER, n, 1, MPI_INTEGER, 0, MPI_COMM_WORLD, ierr)
27 CALL MPI_GATHER(m_local, 1, MPI_INTEGER, m, 1, MPI_INTEGER, 0, MPI_COMM_WORLD, ierr)
28
29 DO x=1, 100
30 region_local%n = n_local*x
31 region_local%m = m_local*x
32
33 CALL MPI_BARRIER(MPI_COMM_WORLD, ierr)
34 ti = MPI_WTIME()
35 CALL region_grid(region_local) ! Creacin de los nodos interiores
36 CALL region_nodenums_p(region_local) ! Numeracin de los nodos
37 CALL region_elements(region_local) ! Creacin de los elementos
38 CALL MPI_BARRIER(MPI_COMM_WORLD, ierr)
39 tf = MPI_WTIME()
40
41 IF (my_rank==0) WRITE(*,*) DOT_PRODUCT(n*x, m*x), tf-ti
42 DEALLOCATE(region_local%node_nums)
43 DEALLOCATE(region_local%node_coords)
44 DEALLOCATE(region_local%elements)
45 END DO
46
47 CALL MPI_FINALIZE(ierr)
48
49 END PROGRAM progam_p_test
GeneracindeMallasde

Generación de Mallas de Elementos Finitos en Paralelo

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Generación de Mallas de Elementos Finitos en Paralelo

Transféré par

Droits d'auteur :

Formats disponibles

UNIVERSIDADDEMENDOZA

Figura 9: Regin cuadrangular.

Vous aimerez peut-être aussi