paralelización del ensamblado de la matriz de rigidez de estructuras planas
DESCRIPTION
paralelización,del,ensamblado,de,la,matriz,de,rigidez,de,estructuras,planasTRANSCRIPT
UNIVERSIDAD MAYOR DE SAN ANDRES
Facultad de Ciencias Puras y Naturales
Postgrado en Informática
Programación Paralela
“Paralelización del Ensamblado de la Matriz de Rigidez de Estructuras Planas”
Proyecto Final
Presentado a: Dr. Daniel Gálvez Lio
Presentado por: Roger Saravia Aramayo
LP - Noviembre de 2007
Resumen
En el presente trabajo se implementa una estrategia de paralelización del cálculo de la matriz de rigidez para estructuras planas como pórticos y otras. Primero, se hace una recopilación esencial del marco teórico sobre análisis estructural y sobre programación paralela. Luego, se expone una estrategia de paralelización de datos así como su implementación y ejecución en un simulador plataforma Linux para lenguaje C que hace uso de las librerías MPI tipo SPMD de computación paralela. Finalmente, se presentan algunas conclusiones.
PALABRAS CLAVE
PROGRAMACIÓN PARALELA, MPI, C, DESCOMPOSICIÓN DE DATOS, DESCOMPOSICIÓN FUNCIONAL, SPMD, MPMD, PARALELISMO A NIVEL LOCAL, PARALELISMO A NIVEL GLOBAL, BCCD, LINUX, ESTRUCTURA, ANÁLISIS ESTRUCTURAL, MATRIZ DE RIGIDEZ, VECTOR DE CARGA GENERALIZADO, SUB-ESTRUCTURACIÓN, PARTICIÓN.
1
Índice
1 INTRODUCCIÓN ......................................................................................................................................................... 2
2 OBJETIVOS .................................................................................................................................................................. 2
3 MARCO TEÓRICO ...................................................................................................................................................... 2
3.1 ¿QUÉ ES EL ANÁLISIS ESTRUCTURAL? .................................................................................................................... 2 3.2 CÓMO SE RESUELVE UNA ESTRUCTURA MEDIANTE EL MÉTODO DE LA RIGIDEZ ................................................................ 3 3.3 PROGRAMACIÓN PARALELA ................................................................................................................................... 5
3.3.1 Cómo hacer Computación Paralela .................................................................................................................. 5 3.3.2 ¿Para qué Computación Paralela? ................................................................................................................... 5 3.3.3 Taxonomía de Computadoras: Clasificación de Flynn ..................................................................................... 5 3.3.4 Consiguiendo Paralelismo ................................................................................................................................ 6 3.3.5 Cómo realizar Programación Paralela............................................................................................................. 7 3.3.6 Message Passing Interface (MPI) ..................................................................................................................... 7 3.3.7 Creando Programas Paralelos ......................................................................................................................... 7
4 DESARROLLO TEÓRICO-PRÁCTICO ................................................................................................................... 8
4.1 PARALELISMO A NIVEL LOCAL ............................................................................................................................... 8 4.2 PARALELISMO A NIVEL GLOBAL .......................................................................................................................... 10 4.3 IMPLEMENTACIÓN EN C – LIBRERÍA MPI DE LA PARALELIZACIÓN DEL ENSAMBLADO DE LA MATRIZ DE RIGIDEZ
DE LA ESTRUCTURA ............................................................................................................................................................ 11
5 CONCLUSIONES ....................................................................................................................................................... 13
6 REFERENCIAS .......................................................................................................................................................... 14
2
1 Introducción
El escenario del presente proyecto se extiende principalmente en la división de programación paralela de las ciencias de computación teniendo como campo de aplicación la rama estructural de la ingeniería civil.
Un problema bien identificado en el cálculo de estructuras de la ingeniería civil es la magnitud de tiempo que consume el algoritmo de análisis estructural. Esto se debe a que dicho análisis se basa en manipulación de matrices y vectores de grandes dimensiones que se corresponden con el sistema de ecuaciones relativo a la estructura.
Se pretende abordar dicho problema mediante la propuesta e implementación rápida de un algoritmo de computación paralela para el ensamblado de la matriz más importante de una estructura plana: la matriz de rigidez.
2 Objetivos
Desarrollar formas de paralelismo que se pueda conseguir en el algoritmo serial del análisis estructural.
Desarrollar e implementar un algoritmo para el ensamblado en paralelo de la matriz de rigidez de estructuras planas.
3 Marco Teórico
3.1 ¿Qué es el Análisis Estructural?
El análisis estructural es una rama de las ciencias físicas y tiene que ver con el comportamiento de las estructuras bajo determinadas condiciones de diseño. Las estructuras se definen como sistemas que soportan cargas y la palabra comportamiento se entiende como su tendencia a deformarse, vibrar, pandearse o fluir dependiendo de las condiciones a las que estén sometidas. Los resultados del análisis se usan para determinar la forma de las estructuras deformadas y verificar si son adecuadas para soportar las cargas para las cuales se han diseñado.
3
Figura 1. Una pórtico es una estructura plana.
3.2 Cómo se Resuelve una Estructura Mediante el Método de la Rigidez
Primero, una estructura debe ser discretizada en un número finito de elementos para que se corresponda con la ecuación:
RKr (1)
K: Es la matriz de rigidez de la estructura de dimensión kk donde k es el número de grados de libertad de la estructura.
r: Es el vector columna de dimensión 1k y representa el vector generalizado de desplazamientos de la estructura.
R: Es el vector columna de dimensión 1k y representa el conjunto generalizado de cargas externas aplicadas a la estructura.
Luego, la matriz de rigidez K de la estructura es ensamblada mediante la contribución de las matrices de rigidez individuales de cada elemento. Similarmente, el vector de carga R de la estructura es ensamblado a partir de los vectores de carga individuales que actúan sobre los elementos. Una vez terminado el proceso de ensamblado, se resuelve el sistema de ecuaciones (1) para hallar el vector generalizado r de desplazamientos de la estructura. Con el vector r y otras ecuaciones matriciales pueden calcularse las fuerzas internas que sufren los elementos así como los esfuerzos relacionados con la sección transversal de los mismos. Todo esto con el fin de diseñar una estructura. Nota: Debido a la naturaleza introductoria de este trabajo, no se desarrollarán las ecuaciones para las fuerzas internas y esfuerzos mencionados.
4
Entonces, la secuencia de los pasos involucrados en la solución secuencial (serial) del análisis estructural son los siguientes (véase la figura 2).
1) Se leen los nudos y los elementos.
2) Se calcula una matriz de rigidez para cada elemento y se añade en la matriz de rigidez de la estructura.
3) Se calcula un vector de carga para cada elemento y se añade al vector carga de la estructura.
4) Se reduce el sistema de ecuaciones (1) mediante la aplicación de condiciones de contorno.
5) Se resuelve el sistema de ecuaciones (1) obteniendo los desplazamientos de los nudos en el vector r.
6) A partir del vector r se calculan las fuerzas internas y esfuerzos en los elementos.
7) Finalmente, se dispone de los resultados.
Un ejemplo: El cálculo de la estructura de la Figura 1 involucra una matriz de rigidez de 15x15 (3 filas y 3 columnas por nudo).
Figura 2. Flujo de un programa de análisis estructural serial. (D. A. R.)
5
3.3 Programación Paralela
La Computación paralela es el empleo de una computadora paralela y la concurrencia para resolver un problema.
La programación es más compleja pues requiere de mecanismos de coordinación de las acciones desarrolladas por los distintos procesadores. La detección de errores de programación también es más complicada.
3.3.1 Cómo hacer Computación Paralela
Supercomputadores
Clusters de Computadoras
3.3.2 ¿Para qué Computación Paralela?
Para solucionar más rápido problemas de cálculo intensivo.
Para solucionar problemas mayores en el mismo tiempo.
Para solucionar problemas mayores en el mismo tiempo.
3.3.3 Taxonomía de Computadoras: Clasificación de Flynn
SISD: un único flujo de instrucciones operando sobre un único flujo de datos.
SIMD: un único flujo de instrucciones operando sobre múltiples flujos de datos.
MISD: múltiples flujos de instrucciones operando sobre un único flujo de datos.
MIMD: múltiples flujos de instrucciones operando sobre múltiples flujos de datos.
o SPMD
Simple Program Multiple Data: Un mismo programa procesa varios flujos de entrada y se ejecutan “simultáneamente” en un grupo de procesadores.
o MPMD
Multiple Program Multiple Data
6
3.3.4 Consiguiendo Paralelismo
Grafo de Dependencia de Datos
Grafo dirigido
Vértices: tareas
Arcos: dependencias
A
B B B
C
Figura 3
Paralelismo de Datos
Tareas independientes aplican la misma operación a diferentes elementos de un conjunto de datos:
for (i=1; i<=M; i++) a[i] = b[i] + c[i];
Ideal para realizar operaciones concurrentemente.
Paralelismo Funcional o de Control
Tareas independientes aplican diferentes operaciones a diferentes elementos datos:
a = 2;
b = 3;
m = (a + b) / 2;
s = (a*a + b*b) / 2;
v = s – m*m;
Algunas instrucciones se pueden hacer de forma concurrente.
Otros Formas de Conseguir Paralelismo
Paralelismo de Flujo (pipeline)
Forma Automática
Forma Manual
7
3.3.5 Cómo realizar Programación Paralela
Bibliotecas para la programación por hilos:
o Win32 API – bajo nivel.
o Threads.hpp – clases de alto nivel.
Directivas de compilación como OpenMP.
Con paso de mensajes:
o MPI
o PVM
3.3.6 Message Passing Interface (MPI)
Especificación estándar para bibliotecas de paso de mensajes.
Bibliotecas disponibles casi para todas las computadoras paralelas.
Bibliotecas libres disponibles para redes de workstations (computadoras) o clusters.
3.3.7 Creando Programas Paralelos
Modelos de Programación
Modelo maestro/esclavo (master/slave).
Modelo piscina de tareas (task pool).
Cómo Crear un Programa Paralelo
1) Al programa en serie ejecutarlo paso a paso y conocer sus interioridades.
2) Identificar las partes del programa que puedan ejecutarse concurrentemente.
a. Comprender el algoritmo.
b. Explotar el paralelismo que pueda existir.
3) Decomponer el programa.
a. Paralelismo funcional
b. Paralelismo de datos
c. Combinación de ambos
8
4 Desarrollo Teórico-Práctico
4.1 Paralelismo a Nivel Local
Un posible enfoque es paralelizar cada paso del algoritmo de análisis estructural (Figura 2) apropiadamente:
a) El ensamblado de la matriz de rigidez de la estructura y el cálculo de las fuerzas internas y esfuerzos en los elementos podría ser paralelizado mediante un mapeo de los elementos de la estructura con un número igual de procesadores disponibles. Un mapeo eficiente debería balancear en lo posible la carga de trabajo de los procesadores con relación al número de elementos de la estructura asignado. Esta estrategia ha producido speed-ups de hasta 90% según algunas experiencias anteriores (Adeli & Kamal, 1989).
b) El ensamblado del vector generalizado de carga de la estructura y la aplicación de las condiciones de borde también podría ser paralelizado. Dicho ensamblado del vector de carga podría ser paralelizado mediante el mapeo de las juntas involucradas de la estructura con un número tan igual como sea posible de procesadores. De la misma manera, las restricciones en los grados de libertad; es decir, las condiciones de borde, podrían gozar de un mapeo similar y tan igual como sea posible con el número de procesadores disponible. Puede apreciarse que en este segundo enfoque la paralelización es posible pero de manera algo distinta al primer enfoque con los pasos anteriores. Es importante notar que, este enfoque resulta más eficiente aplicado a procesadores con memoria compartida que a procesadores con memoria no compartida. Esto se debe a que la memoria compartida es accedida por todos los procesadores todas las veces; consecuentemente, puede tenerse un alto grado de flexibilidad y el programador puede optar por la mejor discretización o patrón de mapeo para el proceso de solución.
Sin embargo, la paralelización no puede extenderse al último paso puesto que la solución de un sistema de ecuaciones es inherentemente secuencial. Se han hecho varios intentos para paralelizar este paso (Adams 1985 y Saad 1986); no obstante, este paso sigue siendo el cuello de botella para el procesamiento concurrente de los problemas de análisis estructural. Farhat et al. (1987) ha demostrado que el efecto del código no paralelizable puede degradar seriamente el speed-up esperado aunque dicho código sea pequeño.
El speed-up, para un número de procesadores NP, se corresponde con la fórmula que ofrece la segunda ley de Amdahl:
9
paralelonotiempoNP
paralelotiempoparalelonotiempoparalelotiempo
upspeed NP
__
___
(2)
Esta ecuación (2) muestra que mientras más largo sea el tiempo del código no paralelizable, más grande será la desviación de un speed-up de tendencia lineal. Este desfase se incrementa con el número de procesadores NP usados.
R: Vector carga
r: Vector desplazamiento
K: Matriz de rigidez
q: (denota sub-dominio)
B: (denota borde)
I: (denota interior)
Figura 4. La sub-estructuración del dominio y su paralelización en el cálculo (D. A. R.)
10
4.2 Paralelismo a Nivel Global
En contraste a la paralelización a nivel local de la estructura (a nivel de los pasos de solución), es posible un enfoque a nivel global (a nivel de la estructura):
Fundamentalmente, se reordena la entrada de datos mediante una partición o sub-estructuración de la estructura de tal manera que los subsiguientes pasos de análisis y diseño puedan ser realizados de manera eficiente sobre una arquitectura multi-procesador. Se trata de particionar la estructura en un número igual de sub-dominios que se corresponda con el número de procesadores disponibles. Esta estrategia de mapeo (la asignación de los procesadores a los sub-dominios) ha probado ser mucho más eficiente que otras estrategias (Adeli & Kamal, 1989). Es importante mencionar que, una vez particionado el dominio de esta manera, las juntas o los nudos de la estructura pasan a clasificarse como “nudos internos”, “nudos interfaz” y “nudos de soporte”. Esto debido a que la sub-estructuración de una estructura lleva algunas consideraciones sumamente importantes a la hora de hacer el cálculo o análisis estructural. Debido a la naturaleza introductoria de este trabajo, no se van a detallar tales consideraciones. La Figura 5 muestra el algoritmo del proceso de solución luego de la paralelización.
Figura 5. Algoritmo de solución en paralelo (D. A. R.)
11
Hasta aquí se ha descrito la sub-estructuración pero no el algoritmo que hace posible la misma. Muchos algoritmos han sido desarrollados al respecto pero deberá elegirse uno que cumpla ciertas características importantes:
Que sea de propósito general; es decir, que permita el manejo de dominios irregulares.
Que sus resultados permitan una carga balanceada con relación al calculo que van a ejecutar los procesadores.
Que provea un pequeño número de nudos interfaz ya que esto reduciría considerablemente el número de ecuaciones simultáneas a ser resueltas en paralelo.
4.3 Implementación en C – Librería MPI de la Paralelización del Ensamblado de la Matriz de Rigidez de la Estructura
Como parte práctica del presente trabajo, se ha programado en C haciendo uso de la librería MPI, la ejecución a grueso modo de dos de los pasos del algoritmo de análisis estructural pero bajo paralelismo local (véase subtítulo 4.1). Se trata del ensamblado de la matriz de rigidez de la estructura acompañado del ensamblado del vector de carga generalizado de la estructura; ambos, conforman el sistema de ecuaciones para el equilibrio estático de la estructura tal como se expuso con anterioridad.
Se ha practicado un paralelismo de datos puesto que tareas independientes aplican la misma operación a diferentes elementos de la estructura. Se ha trabajado en una plataforma que permite SPMD (Simple Program Multiple Data); un mismo programa procesa varios flujos de entrada que se ejecutan “al mismo tiempo” en un número de procesadores.
Para la programación en MPI con un número de procesadores dado, se ha procedido con la siguiente estrategia: A cada procesador se le ha encargado ensamblar un número de filas de la matriz de rigidez de la estructura y del vector de carga generalizado. Este número de filas por procesador depende del número total de procesadores disponibles, el cual a su vez deberá ser de una magnitud que permita la distribución equitativa entera de la carga de trabajo; es decir, el número de filas de la matriz global deberá ser múltiplo del número de procesadores disponibles. Esta última restricción debido a la naturaleza introductoria de este trabajo ya que la misma bien podría no existir en trabajos más elaborados o de aplicación real. Cada fila i de la matriz de rigidez de la estructura se asocia con el elemento de la estructura que parte en el nudo i y que termina en el nudo j, siendo j la columna correspondiente en la fila i. Cada fila i del vector de carga generalizado se asocia con el vector carga aplicado en el nudo i de la estructura.
Para complementar mejor la explicación de la implementación, se presenta a continuación el código en lenguaje C elaborado y comentado de manera apropiada. Más adelante se concluye con la ejecución del programa. Es importante apuntar que, el código elaborado, presentado y ejecutado, fue desarrollado en C para Linux que se incluía en un proyecto denominado BCCD sobre computación paralela.
12
Figura 6. Código en C (MPI) de la Implementación – Pantalla 1
Figura 7. Código en C (MPI) de la Implementación – Pantalla 2
13
Figura 8. Ejecución de la Implementación – Pantalla 2
En la Figura 8 se puede apreciar la pantalla resultado luego de la ejecución del código para una matriz de rigidez de 6x6 y para tres procesadores. Al final del lado derecho aparece también el vector de carga generalizado. Entonces, en la Figura 8 se tiene el sistema de ecuaciones de una estructura hipotética cuyos desplazamientos de sus juntas están dados por los elementos del vector de desplazamiento D.
5 Conclusiones
El algoritmo para particionar una estructura deberá ser portable y lo suficientemente flexible como para ser usado en problemas de análisis estructural bajo arquitecturas multi-procesador.
Es importante mantener el balance en la carga de trabajo asignado a cada procesador y durante el proceso de solución.
La solución del sistema de ecuaciones simultáneas sigue siendo un cuello de botella en la eficiencia de aplicaciones concurrentes o de computación paralela. Para estructuras sumamente grandes el efecto del sistema de ecuaciones es menos severo puesto que el porcentaje del tiempo secuencial requerido para resolver el sistema, es generalmente pequeño comparado con el tiempo total.
14
6 Referencias
H. ADELI & KAMAL (1993) “Parallel Processing in Structural Engineering”. Elsevier Sciencie Publishers. England.
DANIEL GÁLVEZ L. (2007) "Introducción a la Programación Paralela". Postgrado en Informática, UMSA. LP-BOL.
BLAISE BARNEY (2007) “Message Passing Interface (MPI)”. Livermore Computing. [En red]. Disponible en: http://www.llnl.gov/computing/tutorials/mpi/
PETER NORTON (2002) "New Inside The PC". Second Edition. SAMS. Indiana-USA.