Paralelización de un Algoritmo para la Detección de Clusters de Galaxias

73 Pages·2012·2.07 MB·Spanish

UNIVERSIDAD DE CHILE
FACULTAD DE CIENCIAS FÍSICAS Y MATEMÁTICAS
DEPARTAMENTO DE CIENCIAS DE LA COMPUTACIÓN

PARALELIZACIÓN DE UN ALGORITMO PARA LA DETECCIÓN DE CÚMULOS
DE GALAXIAS

MEMORIA PARA OPTAR AL TÍTULO DE INGENIERO CIVIL EN
COMPUTACIÓN

MARCEL ANDRE AUGSBURGER BECERRA

PROFESOR GUIA:
NANCY HITSCHFELD KAHLER

MIEMBROS DE LA COMISION:
LUIS CAMPUSANO BROWN
JORGE PÉREZ ROJAS

SANTIAGO DE CHILE
ENERO 2012
Tabla de contenido
Resumen ......................................................................................................................................................... 4
1. Introducción ........................................................................................................................................... 5
1.1. La nueva astronomía ...................................................................................................................... 5
1.2. La computación paralela ................................................................................................................ 6
1.3. Motivación ..................................................................................................................................... 7
1.3.1. Importancia del análisis de cúmulos de galaxias ................................................................... 7
1.3.2. Importancia del análisis paralelo ........................................................................................... 7
1.3.3. Otras aplicaciones del software ............................................................................................. 8
1.4. Objetivos ........................................................................................................................................ 8
1.5. Contenido de la memoria ............................................................................................................... 9
2. Antecedentes .......................................................................................................................................10
2.1. Tipos de paralelismo ....................................................................................................................10
2.2. Herramientas ................................................................................................................................12
2.3. Algoritmo secuencial de detección de cúmulos de galaxias ........................................................14
3. Análisis ..................................................................................................................................................17
Arquitectura de ................................................................................................................................17
3.1. Hadoop .........................................................................................................................................17
3.1.1. Distribución de datos ...........................................................................................................18
3.1.2. Procesamiento de datos .......................................................................................................19
3.1.3. Escalabilidad .........................................................................................................................21
3.1.4. HDFS .....................................................................................................................................21
3.1.5. MapReduce ..........................................................................................................................24
3.2. Arquitectura de Vocludet .............................................................................................................26
3.3. Versión disponible de Vocludet ...................................................................................................29
3.4. Alternativas de implementación ..................................................................................................32
2
3.4.1. MapReduce de Hadoop ........................................................................................................32
3.4.2. Pig .........................................................................................................................................32
3.4.3. Streaming .............................................................................................................................33
3.5. Alternativa escogida .....................................................................................................................34
4. Diseño e Implementación ....................................................................................................................35
4.1. Diseño de la solución ....................................................................................................................35
4.1.1. División de los datos .............................................................................................................36
4.1.2. Procesamiento de los datos .................................................................................................39
4.1.3. Re ensamblaje de los resultados ..........................................................................................40
4.1.4. Diseño final ...........................................................................................................................41
4.2. Código Implementado ..................................................................................................................43
5. Evaluación ............................................................................................................................................52
5.1. Datos de prueba ...........................................................................................................................52
5.2. Pruebas .........................................................................................................................................54
5.2.1. Particiones ............................................................................................................................54
5.2.2. Ensamblaje ...........................................................................................................................54
5.2.3. Verificación de datos y procedimientos ...............................................................................57
5.3. Desempeño ..................................................................................................................................60
5.3.1. Uso de recursos ....................................................................................................................60
5.3.2. Desempeño comparativo .....................................................................................................61
6. Conclusiones.........................................................................................................................................65
7. Anexos ..................................................................................................................................................66
Tabla 3: Distribución de cúmulos por tamaño .........................................................................................66
Mapper Function 2 celdas 10% de overlap ..............................................................................................67
Re Assembly Function ..............................................................................................................................70
8. Bibliografía ...........................................................................................................................................72
3
Resumen
Dados los avances en la tecnología, la astronomía es capaz de recolectar del orden de terabytes de datos
por noche. El análisis manual de ésta es prácticamente imposible, por lo que es constante la necesidad
de nuevos y mejores algoritmos para realizar análisis automático. Por otro lado, la computación paralela
provee herramientas para realizar análisis de datos masivos, las que incrementan la capacidad total de
procesamiento y disminuyen el tiempo requerido.
Existe un software para la búsqueda de cúmulos de galaxias, el cual funciona de forma secuencial. Hacer
que este software funcione en forma paralela sería de gran utilidad, dada la cantidad de datos que
existen y existirán para analizar. El objetivo de esta memoria es diseñar e implementar una solución
computacional que permita efectuar la detección de cúmulos de galaxias en forma paralela.
La paralelización del algoritmo se hizo sobre el framework Hadoop, utilizando la herramienta Streaming
con el lenguaje Python para el desarrollo del software. Se construyó una aplicación que divide los datos
de entrada de forma inteligente, ejecuta el algoritmo de detección de cúmulos de galaxias en varias
máquinas de forma paralela, y re ensambla los resultados parciales obtenidos. Se estudiaron estrategias
para el particionamiento de los datos, utilizando celdas con distintas geometrías. También se estudiaron
e implementaron estrategias para el re ensamblado de los resultados. En base a conocimientos
astronómicos y experimentación se determinó la utilidad, dado el contexto, de cada estrategia, y los
valores límites para sus parámetros.
Los resultados son los siguientes: (1) un software paralelo para la detección de cúmulos de galaxias; (2) al
correr el programa paralelo con dos particiones, el tiempo de ejecución se reduce a la mitad; (3) el
software secuencial de detección de cúmulos se observa altamente dependiente de las particiones
utilizadas, encontrándose para una partición de 2 celdas sólo un 11% de los cúmulos que se detectaban
en la versión secuencial.
Como trabajo futuro se propone: (1) modificar el software secuencial de búsqueda de cúmulos de
galaxias para que detecte cúmulos sin miembros repetidos; (2) ejecutar este software en un clúster de
computadores o con cloud computing, para medir las mejoras en tiempo; (3) la ejecución de este
software con sets de datos más grandes, para medir la escalabilidad de éste; (4) crear una partición ad-
hoc al set de datos.
4
1. Introducción
Desde la antigüedad, diferentes culturas y personas han creado catálogos de estrellas. Al principio se
hacían observaciones a ojo desnudo, hasta que en 1610 Galileo Galilei apuntó su telescopio al cielo. Al
irse mejorando las capacidades de los telescopios, la cantidad de información astronómica y por ende los
catálogos estelares fueron creciendo en gran escala. Hoy en día las herramientas de observación
permiten escanear el cielo y guardar los datos de manera automática, generando terabytes de
información sólo de pequeñas áreas del cielo.
Al haber tanta información, el análisis manual de ésta es prácticamente imposible, por lo que es
constante la necesidad de nuevos y mejores algoritmos computacionales para realizar análisis
automático. A pesar de ser mucho más eficiente, la gran cantidad de datos hace que el análisis
computacional requiera de mucho tiempo de procesamiento. La computación paralela puede disminuir
los costos en tiempo, ya que permite aumentar los recursos asignados a cada tarea.
La computación paralela divide un problema en varios sub problemas, los que son resueltos de manera
concurrente. De tal manera se puede resolver cada sub problema con distintos recursos, pudiendo
distribuir la carga en equipos que pueden estar separados físicamente. Sin embargo, los programas
paralelos agregan dificultad en los procesos de división del problema, en la concurrencia, y en el re
ensamblado de la solución completa a partir de las soluciones parciales.
Existe un software desarrollado por Daniel Pizarro et al, el cual aplica un algoritmo basado en el Voronoi
Tessellation Technique (1) para la detección de cúmulos de galaxias. Este software lleva por nombre
Vocludet. Uno de los componentes del Vocludet es el Voronoi Tessellation Maximum Likelihood
Estimator, en adelante VTMLE, el cual lleva a cabo el proceso de búsqueda de cúmulos (2). Este software
funciona de manera secuencial.
1.1. La nueva astronomía
Gracias a los avances en la tecnología de los telescopios, algoritmos de detección, y hardware
computacional, la recolección de datos astronómicos es actualmente del orden de terabytes por noche
(4). Este incremento en la obtención de datos ha ocurrido en muchas áreas de la ciencia, cambiando la
forma en que se hace la investigación y transformándola en análisis de datos sobre bases de datos con
mucha información. En el área de la astronomía se habla del Observatorio Virtual, donde se puede
acceder a la información de distintos centros de datos de manera relativamente fácil y transparente. Se
5
están aportando datos y relacionándolos entre sí a tasas cada vez mayores, lo cual ha tornado la
obtención de datos por este medio en algo tan importante como la obtención de datos a través de
telescopios.
En los últimos años se han puesto a disposición resultados de numerosos estudios con distintos tipos de
información astronómica. En particular existen datos e interés en la estructura a gran escala del
universo, donde han jugado un rol importante las observaciones de cúmulos de galaxias, al servir para
contrastarlas con las predicciones de diferentes modelos teóricos.
Los cúmulos de galaxias, mencionados previamente, son sistemas que contienen desde 50 a 1000
galaxias unidas por atracción gravitacional mutua; las galaxias son sistemas de estrellas, las cuales
poseen típicamente cientos de miles de millones de estrellas. Estos cúmulos han sido detectados
históricamente en forma visual, y recientemente se han aplicado algoritmos para la detección
automática de éstos.
El sondeo 2dF Galaxy Redshift Survey (2dFGRS), llevado a cabo por el Observatorio Anglo-Australiano
entre 1997 y 2002, generó variados tipos de información respecto a galaxias, incluyendo su distribución
al determinar su posición en tres dimensiones (5). La estimación de distancias es posible gracias a la
información del corrimiento al rojo, que es el aumento de la longitud de onda equivalente al Efecto
Doppler en las ondas físicas.
1.2. La computación paralela
La computación paralela es la utilización simultánea de múltiples recursos de computación para resolver
problemas computacionales.
Tradicionalmente, el software ha sido escrito para ser ejecutado en forma secuencial. Esto significa que
para resolver un problema, el algoritmo que se implementa debe ser escrito como una secuencia de
instrucciones. Como restricción se tiene que estas instrucciones deben ser ejecutadas una a la vez, y
solamente en el orden especificado por el algoritmo. Cada una de estas instrucciones es ejecutada por
una CPU (Central Processing Unit). El tiempo que demora la resolución del problema depende de la
eficiencia del algoritmo y de la rapidez con la que la CPU realiza los cálculos, haciendo que este último
factor haya sido y siga siendo sujeto de estudio.
6
Por décadas, la velocidad de procesamiento de los computadores ha ido incrementando según la Ley de
Moore, esto es, duplicándose cada aproximadamente dos años (6). Este incremento se ha debido en
gran medida al aumento de la frecuencia de reloj de los procesadores, sin embargo se está llegando a un
límite conocido como power wall, debido al consumo exponencial de energía con el aumento en la
frecuencia de operaciones, y el consiguiente aumento de temperatura. Existen también cuellos de
botella como la rapidez de acceso a la memoria, por lo que el desarrollo de procesadores más rápidos
no necesariamente va a significar un incremento en la eficiencia final de los computadores.
En la búsqueda de cómo continuar incrementando la capacidad de procesamiento, y tomando en cuenta
otros factores limitantes, se ha considerado el paralelismo como buena solución. La computación
paralela se ha usado históricamente, mostrando buenos resultados en distintas áreas, como en
computación de alto rendimiento, servidores, aceleración gráfica, y muchos sistemas embebidos (7). Así
podemos encontrar actualmente diseños de procesadores con múltiples núcleos, los cuales permiten
realizar varios cálculos por ciclo, para computadores multipropósito.
1.3. Motivación
Existe un software para la búsqueda de cúmulos de galaxias, el cual funciona de forma secuencial. Hacer
que este software funcione en forma paralela es de gran utilidad, dada la cantidad de datos que existen y
existirán a futuro para analizar.
1.3.1. Importancia del análisis de cúmulos de galaxias
Los cúmulos de galaxias son de gran interés para la astronomía. En las últimas décadas han tenido un
importante rol en el estudio cosmológico: sirven para reconocer las estructuras en gran escala del
universo, su densidad numérica se puede contrastar con predicciones de distintos modelos, y además
sirven para monitorear la formación y evolución de las galaxias (9).
1.3.2. Importancia del análisis paralelo
Como se mencionó, hoy se cuenta con un observatorio virtual con grandes cantidades de datos. Futuros
sondeos prometen aumentar el volumen de datos en órdenes de magnitud, produciendo una llamada
“avalancha de datos astronómicos”.
7
La ciencia en general ha logrado producir más datos de los que se pueden analizar, y dada esta
problemática, es de gran importancia primero lograr el análisis automático de los datos, e
inmediatamente lograr paralelizarlo para aminorar los tiempos de procesamiento. Lo relevante de esta
tarea para la astronomía, la aplicabilidad en otras ramas de la ciencia, y la conocida dificultad de
paralelizar procesos, hacen de éste un tema interesante como memoria.
1.3.3. Otras aplicaciones del software
El análisis de cúmulos es un problema recurrente en varias áreas, entre éstas el aprendizaje automático,
reconocimiento de patrones, análisis de imágenes, recuperación de la información y bioinformática.
Dado que el software desarrollado se creó de manera flexible, éste puede ser usado no sólo en el análisis
de datos astronómicos, sino que también en cualquiera de las áreas recién mencionadas. Si bien la
aplicación secuencial ya lo permitía, el desarrollo de este análisis en paralelo abre las puertas al
procesamiento de órdenes de magnitud mayor de datos, pudiéndose atacar problemas que de otra
manera hubiese sido imposible.
1.4. Objetivos
El objetivo general es diseñar e implementar una solución computacional que permita detectar cúmulos
de galaxias en forma paralela, utilizando un framework que permita distribuir la carga de procesamiento.
Los objetivos específicos son:
 Construir una aplicación utilizando el framework Hadoop para llevar a cabo el análisis de datos
en forma paralela. Lo anterior considera el diseño e implementación de un programa que realice
una buena partición de los datos, resuelva el problema sobre cada partición, y calcule la solución
completa re ensamblando los resultados parciales.
 Evaluar si se efectúa una mejora a la solución existente, lo que implica comparar la aplicación
secuencial y la aplicación paralela en término de tiempos y consumo de recursos.
 Determinar las diferencias y similitudes entre los resultados obtenidos por el programa
secuencial y el paralelo .
8
1.5. Contenido de la memoria
En la sección 2 se presentan las tecnologías disponibles y el algoritmo que se quiere paralelizar. En la
sección 3 se analizan las herramientas con las que se cuenta para el desarrollo del software, se comparan
las diferentes alternativas y su estado, y se decide cuáles se van a utilizar y de qué forma. En la sección 4
se presentan las decisiones que se consideraron para el diseño del software, se propone un diseño final,
y se muestra y explica el código implementado. En la sección 5 se presentan los experimentos realizados
para probar el software y determinar su eficacia y eficiencia. Se incluye una descripción de los datos de
prueba, las pruebas mismas, y el desempeño del software. Finalmente, en la sección 6 se presentan las
conclusiones a las que se llegó con este trabajo, según los objetivos que se habían planteado, y se
proponen acciones para continuarlo a futuro.

9
2. Antecedentes
En este capítulo se presentan los antecedentes del problema, tales como las tecnologías disponibles y el
algoritmo que se quiere paralelizar.
2.1. Tipos de paralelismo
La computación paralela se puede llevar a cabo en varios niveles, desde la cantidad de bits que se
pueden procesar por ciclo, la cantidad de instrucciones que se pueden procesar en forma paralela, la
paralelización en procesamiento de datos, hasta la paralelización de tareas. De todos modos, sólo se
pueden realizar ciertos cálculos en paralelo: algunos deben ser secuenciales pues dependen de
resultados obtenidos por cálculos previos. Se puede hacer una clasificación de los computadores que
trabajan en forma paralela según el nivel al cual el hardware provee el paralelismo. Para el paralelismo a
nivel de núcleos de procesamiento, esta clasificación es a grandes rasgos análoga a la distancia entre los
nodos básicos de computación, y no son mutuamente excluyentes.
 Computación Multinúcleo: Un procesador multinúcleo es aquel que posee múltiples unidades de
ejecución (núcleos) en el mismo chip. Estos procesadores tienen la capacidad de ejecutar
múltiples instrucciones por ciclo, provenientes de múltiples flujos de instrucciones.
 Multiprocesamiento Simétrico: Un multiprocesador simétrico es un computador que posee
múltiples procesadores idénticos, los cuales comparten el acceso a la memoria a través de un
único bus de datos. Esto permite asignar más de un procesador a una o varias tareas. Dado el
diseño del acceso a datos, los multiprocesadores simétricos suelen no tener más de 32
procesadores.
 Computación Distribuida: La computación distribuida es un modelo de computación donde se
usan múltiples computadores para la resolución de un problema. Estos se coordinan entre sí a
través de un sistema distribuido, definido como: una colección de computadores separados
físicamente y conectados entre sí por una red de comunicaciones distribuida, donde cada
máquina posee sus componentes de hardware y software que el usuario percibe como un solo
sistema. Se define como nodo a una unidad individual, típicamente una máquina, dentro de un
sistema distribuido.
El framework utilizado en el presente trabajo se construyó para que pudiese ser utilizado por cualquiera
de las tres clases de computación paralela, abstrayéndose de este nivel y funcionando indiferente a la
10