Embed Size (px)
Citation preview
UNIVERSIDAD DE COLIMA
FACULTAD DE TELEMÁTICA
PARALELIZACIÓN DE FILTROS DE
CORRELACIÓN PARA DETECCIÓN DE
OBJETOS CON MATLAB
TESIS
QUE PARA OBTENER EL GRADO DE
MAESTRO EN COMPUTACIÓN
Presenta
ING. MARTIN SARABIA AQUINO
Asesores:
Dra. Erika M. Ramos Michel
Dr. Juan Manuel Ramírez Alcaraz.
Colima, Col., Enero de 2012
Colima, Col., Enero de 2012
M. en C. Ricardo Acosta Díaz Director de la Facultad de Telemática P R E S E N T E Por medio de este conducto informo que le trabajo de tesis para obtener el grado de Maestría en Computación del C. MARTIN SARABIA AQUINO, ha sido revisado y aprobado por sus servidores y puede continuar con los trámites de titulación que estén estipulados.
El título de la tesis es: “Paralelización de Filtros de Correlación para Detección de Objetos con MatLab”, cuyo contenido ha sido examinado y encontrado adecuado a la finalidad que se propone conseguir y ha quedado desarrollado bajo los siguientes puntos:
Capítulo I.-Introducción Capítulo II.-Antecedentes del cómputo paralelo Capítulo III.-Cómputo paralelo en MatLab. Capítulo IV.-Procesamiento de imágenes Capítulo V.-Desarrollo de la paralelización Capítulo VI.-Análisis experimental Bibliografía
Sin otro particular, reciba un cordial saludo.
Atte.
______________________________ D. en C. Erika M. Ramos Michel
Profesor e Investigador Universidad de Colima
Asesora de la Tesis
______________________________ D. en C. Juan M. Ramírez Alcaraz
Profesor e Investigador Universidad de Colima Coasesor de la Tesis
iii
Resumen
El presente trabajo está dirigido a resolver el reconocimiento de objetos a través de filtros
correlacionados en imágenes utilizando procesamiento en paralelo. Cuando las imágenes son a
color, se requiere mayor procesamiento de cómputo para llevar a cabo el reconocimiento de
objetos, para lo cual, en este trabajo se presenta una solución para llevar a cabo esta tarea a
través de un ambiente de procesamiento paralelo con la finalidad de mejorar los tiempos de
procesamiento y reconocimiento, proponer un ambiente de procesamiento en paralelo y los
algoritmos para realizar el reconocimiento de objetos con filtros de correlación en imágenes de
forma confiable y rápida. Se presentan resultados del uso del procesamiento paralelo en la
aplicación de filtros de correlación comparando la velocidad de procesamiento para realizar el
reconocimiento de objetos con filtros de correlación en imágenes cuando se implementan en
un ambiente paralelo y en un ambiente secuencial.
iv
Abstract The aim of this research is to create an efficient system of object recognition and identification
with correlated filters in images by using parallel processing. When images are in color, it
requires more computer processing time to perform object recognition. This paper presents a
method to improve processing times and recognition via the implementation of a parallel
processing environment. It outlines a practical parallel environment and the algorithms needed
in order to perform object recognition quickly and reliably by utilizing correlated filters in
images. This study documents how processing speed is improved through the use of a parallel
processing environment with correlation filters in comparison to the traditional use of a
sequential environment.
v
Agradecimientos
La presente Tesis es un esfuerzo conjunto de la participación directa o indirectamente de
varias personas, que revisando, corrigiendo, escuchando y dando ánimo en los momentos de
crisis y de felicidad.
Mi más sincero agradecimiento:
A mí querida esposa por su amor y apoyo incondicional.
A la Dra. Erika M. Ramos Michel por su gran apoyo, dedicación y compresión como directora
de tesis.
D. en C. Juan M. Ramírez Alcaraz por su dedicación y consejos.
A mis sinodales M.C. Maria Andrade Arechiga y M.C. José Moctezuma Hernández por el
apoyo brindado.
A todas las personas que he tenido la oportunidad de conocer y que de alguna manera
contribuyeron a este trabajo.
vi
Dedicatorias
A dios por brindarme la fuerza con la que vivo siempre.
A mis padres por una infinidad de cosas.
A mi querida Familia por que en los momentos más difíciles
sigue a mi lado,
A mis dos pequeños hijos Jesús Marti y Celeste Madahi.
vii
Tabla de Contenido Página
Resumen ................................................................................................................... iii
Resumen en Inglés ................................................................................................... iv
Agradecimientos ....................................................................................................... v
Dedicatorias .............................................................................................................. vi
Lista de figuras .......................................................................................................... x
Lista de tablas ......................................................................................................... xii
Capítulo I.- Introducción ........................................................................................... 1
I.1 Motivaciones del trabajo ..................................................................................... 2
I.2 Objetivo ............................................................................................................... 3 I.3 Objetivos Específicos.......................................................................................... 3 I.4 Justificación ........................................................................................................ 3
I.5 Limitaciones y Suposiciones ............................................................................... 4
Capítulo II.- Antecedentes del cómputo paralelo ................................................... 6
II.1 Procesamiento paralelo y distribuido. ................................................................ 6 II.1.1 Multiprocesamiento ...................................................................................... 7
II.1.1.1 Sistemas multiprocesamiento ................................................................. 8 II.1.1.2 Confiabilidad. .......................................................................................... 9
II.1.1.3 Paralelismo en computación ................................................................. 10 II.1.1.4 Arquitecturas paralelas y Aplicaciones................................................. 10 II.1.1.5 Modelos multiprocesadores de Von Neumann ..................................... 12
II.1.1.6 Taxonomía de Flynn ............................................................................. 12 II.1.1.6.1 Flujo único de instrucciones, flujo único de datos (SISD) ................. 13 II.1.1.6.2 Flujo único de instrucciones, flujo múltiples de datos (SIMD) ........... 14
II.1.1.6.3 Flujo múltiple de instrucciones, flujo único de datos (MISD) ............. 15
II.1.1.6.4 Flujo múltiple de instrucciones, flujo múltiple de datos (MIMD)......... 15 II.1.2 Multinúcleo ................................................................................................. 17
II.1.2.1 Aprovechamiento de la Tecnología Multithreading y (Multitarea). ........ 18 II.1.2.2 Optimización de las Aplicaciones de Software ...................................... 18 II.1.2.3 Potencial de escalabilidad de los procesadores multinúcleo ................ 18
II.1.2.4 Tecnologia Hyper-Threading® (HT). ..................................................... 22 II.1.3 Cluster Computing (Computación en Cluster) ............................................ 23
II.1.3.1 Componentes ........................................................................................ 23
viii
Tabla de Contenido (continuación) Página
II.1.3.2 Cluster Beowulf ..................................................................................... 24 II.1.3.3 MPI (Message Passing Interface) ......................................................... 25 II.1.3.4 PVM (Parallel Virtual Machine) ............................................................. 26
II.1.3.5 Cluster Mosix ........................................................................................ 26 II.1.4 Grid Computing (Computación en Grid) .................................................... 27
II.1.4.1 Características de Grid Computing ....................................................... 29 II.1.4.2 Arquitectura ........................................................................................... 29
II.1.4.3 Nivel Infraestructura .............................................................................. 29 II.1.4.4 Nivel Conectividad ................................................................................ 29
II.1.4.5 Nivel Recurso ........................................................................................ 30 II.1.4.6 Nivel Recursos ...................................................................................... 30
II.1.4.7 Nivel Aplicaciones ................................................................................. 30 II.1.4.8 Desventajas .......................................................................................... 30
Capítulo III.- Cómputo paralelo en MatLab. ........................................................... 32
III.1 Ciclos .............................................................................................................. 34 III.2 Principios para cambiar un código simple a paralelo. ..................................... 36
Capítulo IV.- Procesamiento de imágenes ............................................................ 39
IV.1 ¿Qué es una imagen? .................................................................................... 39 IV.2 Procesamiento de imágenes .......................................................................... 40 IV.3 Ruido. ............................................................................................................. 40
IV.4 Filtros gráficos de reconocimiento basados en correlación ............................ 41 IV.5 Capacidad de Discriminación (DC) ................................................................ 42
IV.6 Error de Localización. ..................................................................................... 42 IV.6.1 Filtro Espacial de Correspondencia (MSF) ............................................... 43 IV.6.2 Filtro Inverso (IF) ...................................................................................... 43
IV.6.3 Filtro de Sólo Fase (POF) ......................................................................... 44 IV.6.4 Filtro óptimo (OF) ...................................................................................... 44 IV.6.5 Implementación de los filtros de correlación ............................................. 45
Capítulo V.- Desarrollo de la paralelización .......................................................... 47
V.1 Características de aplicaciones paralelas ....................................................... 47
V.2 Aceleración (SpeedUp) ................................................................................... 48 V.3 Eficiencia. ........................................................................................................ 49 V.4 Herramientas de Hardware ............................................................................. 49
V.4.1 Servidor DELL ........................................................................................... 50 V.4.2 Equipo Personal ........................................................................................ 50
V.5 Herramientas de Software. .............................................................................. 50 V.6 Algoritmo Secuencial. ...................................................................................... 51
ix
Tabla de Contenido (continuación) Página
V.7 Configuración del Entorno ............................................................................... 53
V.7.1 MatLab Parallel Computing Toolbox .......................................................... 53 V.7.2 MatLab Distributed Computing Server, ...................................................... 53
V.7.3 Administrador de trabajos (Scheduler) ...................................................... 54 V.7.4 Implementación del Cluster. ...................................................................... 56
V.7.4.1 Creación del Administrador de Trabajos (Scheduler) ........................... 57 V.7.4.2 Creación de las sesiones de trabajo. .................................................... 58
V.8 Configuración de MatLab ................................................................................ 60 V.9 Algoritmo Paralelo. .......................................................................................... 60
Capítulo VI.- Análisis experimental ........................................................................ 63
VI.1 Características del Experimento ..................................................................... 63
VI.2 Análisis de Resultados ................................................................................... 63
Conclusiones ........................................................................................................... 70
x
Lista de figuras Página
Figura 1: a) multiprocesador con 16 cpu que comparten una misma memoria; b) imagen dividida en 16 secciones, cada una de las cuales se analiza con una cpu distinta. ........................................................................................................................ 9 Figura 2: estructura de un procesador multinúcleo ................................................... 11 Figura 3: a) modelo original de un procesador, b) modelo multiprocesador ............. 12 Figura 4: modelo sisd ................................................................................................ 13
Figura 5: modelo simd ............................................................................................... 14
Figura 6: modelo misd ............................................................................................... 15
Figura 7: modelo mimd .............................................................................................. 16 Figura 8: número de núcleos x procesador ............................................................... 20 Figura 9: desempeño efectivo de dos procesadores mono núcleo a 3.6 ghz de velocidad ................................................................................................................... 21
Figura 10: desempeño efectivo de dos procesadores multi núcleo a 2.8 ghz de velocidad ................................................................................................................... 21
Figura 11: representación gráfica de un cluster beowulf ........................................... 25 Figura 12: representación gráfica de un cluster mosix .............................................. 27 Figura 13: representación gráfica de un grid (tomada de www.gridcafe.org) ............ 28
Figura 14: ejecución de código en forma paralela por el parfor................................. 36 Figura 15: (a) estructura de una imagen digital; (b) imagen digital con tres espectros .................................................................................................................................. 40 Figura 16:(a) ruido; (b) imagen adquirida; (c) imagen con ruido ................................ 41
Figura 17: (a) objeto a localizar; (b) escena que contiene el objeto .......................... 45 Figura 18: plano de correlación obtenido entre el objetivo y la escena de la figura 17(a): (a) en tres dimensiones; (b) en dos dimensiones ........................................... 46
Figura 19: diagrama de estados de la aplicación de los filtros de correlación ........... 51 Figura 20: tiempos requeridos por el programa secuencial para procesar 30 imágenes ................................................................................................................... 52 Figura 21: diagrama de bloques de workers locales ................................................. 54 Figura 22: configuración del planificador de trabajos del cluster ............................... 55
Figura 23: ruta de trabajo para inicializar el cluster ................................................... 56 Figura 24: instalación e inicialización del mdce ......................................................... 56 Figura 25: resultado de nodestatus ........................................................................... 57
Figura 26: inicialización del administrador de trabajos jbcluster ................................ 58
Figura 27: creación de un worker y la asignación al administrador de trabajos jmcluster .................................................................................................................... 59 Figura 28: información retornada por el comando nodestatus .................................. 59 Figura 29: configuración interna del matlab del nuevo planificador ........................... 60 Figura 30: uso del nuevo administrador de trabajos desde matlab ........................... 60 Figura 31: representación de una ejecución paralela ................................................ 62 Figura 32: comparativo de los tiempos de procesamiento secuencial vs paralelo .... 65
xi
Lista de figuras (continuación) Página
Figura 33: comparativo general de los tiempos de procesamiento hasta 4 procesadores ............................................................................................................. 66 Figura 34: promedio en horro de tiempo con procesamiento paralelo ...................... 67
Figura 35: porcentaje promedio de ahorro en tiempo ................................................ 67 Figura 36: speedup real vs ideal ............................................................................... 68 Figura 37: medición de la eficiencia del algoritmo paralelo hasta con 10 procesadores .................................................................................................................................. 69
xii
Lista de tablas Página
Tabla I: Taxonomía de Flynn ..................................................................................... 13
Tabla II: Uso de procesadores con tecnología X86 en la lista top500.org ................. 19 Tabla III: Instrucciones for y parfor ............................................................................ 34 Tabla IV: a) ciclo secuencial; b) Ciclo paralelo con variables dependientes ............. 35 Tabla V: Tiempos de procesamiento del algoritmo de filtros de correlación de uno a cinco núcleos ............................................................................................................. 64
Tabla VI: Tiempos de procesamiento del algoritmo de filtros de correlación de seis a diez núcleos .............................................................................................................. 64
Capítulo I.- Introducción
Cuando apareció la computadora, se comenzó una era de progresos significativos en todas las
áreas sociales. La computación ha sido una herramienta indispensable para el progreso de la
sociedad, está involucrada desde los ambientes estudiantiles hasta la conquista del espacio. Por
tal motivo, el uso del procesamiento computacional ha ido en crecimiento, llevado de la mano
con los avances en la tecnología de hardware, los cuales permiten construir microprocesadores
capaces de procesar en un menor tiempo y, que junto con el desarrollo de algoritmos
específicos se hace posible el procesamiento de información en tiempo real.
El cómputo paralelo ha sido el resultado de los avances en hardware, integrando más de un
procesador en un sistema logrando avances significativos en el poder de cálculo, con la
finalidad de poder satisfacer las demandas de poder computacional para tareas que requieren
un alto grado de procesamiento, como lo es el reconocimiento de imágenes, la decodificación
de señales discretas, problemas de inteligencia artificial, predicción meteorológica, reacciones
químicas entre otras.
Los filtro gráficos son un proceso matemático que nos permite discriminar o resaltar
características específicas en una imagen, y con el término correlación se indica la
correspondencia o la relación recíproca que se da entre dos o más objetos. De lo anterior, se
tiene que los filtros de correlación permiten reconocer la posición de un objeto dentro de una
imagen que lo contenga, donde previamente se proporciona la imagen del objeto como
referencia y se realiza el proceso de localización a través de la aplicación del filtro. En el
resultado se resaltan las posiciones donde existe un alto grado de correspondencia con la
imagen del objeto de referencia. En este documento se presenta la solución del reconocimiento
de objetos a través de filtros correlacionados en imágenes a través del procesamiento en
paralelo.
2
I.1 Motivaciones del trabajo
Dado que el reconocimiento de objetos en imágenes a color requiere mucha carga de
procesamiento y tiempo para realizarse, se encuentra un área de oportunidad para realizar un
trabajo de investigación que resuelva dicha tarea a partir de filtros de correlación aplicando
procesamiento paralelo como motivación de este trabajo.
A pesar de los avances tecnológicos y del gran poder computacional alcanzado, el trabajar con
imágenes representa un problema debido a la resolución y a la gran cantidad de información
que contienen las imágenes a color, en sus espectros RGB(de sus siglas en inglés rojo, verde y
azul) ya que la cantidad de operaciones crece drásticamente afectando de manera proporcional
los tiempos requeridos para la finalización de la tarea (Greenberg y Greenberg, 1995).
El reconocimiento de patrones por correlación es un subconjunto del reconocimiento de
patrones estadístico y se basa en seleccionar o crear una señal de referencia para determinar
qué tanto se le parece el objeto a examinar. Cuando se trabaja con imágenes aplicando filtros
de correlación para la detección de objetos, los algoritmos pueden requerir tiempos elevados
de procesamiento (B. V. K. Vijaya, Abhijit, y Richard, 2005).
Los métodos basados en correlación son una de las técnicas más usadas en robótica, visión e
inteligencia artificial. Entre algunas de las ventajas que presentan estos métodos se pueden
mencionar las siguientes: tienen buen fundamento matemático, pueden implementarse de
manera óptica y/o digital, son invariantes a desplazamientos y no requieren de la segmentación.
Sin embargo, también es sabido que son muy sensibles a degradaciones que modifican los
niveles de intensidad de la imagen y a distorsiones geométricas presentes en el objeto a
identificar (Ramos Michel, 2008).
Cuando las imágenes son a color, se requiere mayor procesamiento de cómputo para llevar a
cabo el reconocimiento de objetos, en este trabajo, se presenta una solución para llevar a cabo
3
esta tarea a través de un ambiente de procesamiento paralelo con la finalidad de mejorar los
tiempos de procesamiento y reconocimiento.
Con base a lo anterior, en esta investigación se aborda el problema a través de los objetivos
que a continuación se presentan.
I.2 Objetivo
Implementar un ambiente de procesamiento en paralelo y los algoritmos para realizar el
reconocimiento de objetos con filtros de correlación en imágenes a color en forma confiable y
rápida.
En función del objetivo general planteado, se establecen los siguientes objetivos específicos:
I.3 Objetivos Específicos
Analizar las técnicas de programación en ambientes paralelos aplicables al
reconocimiento de objetos en imágenes a color.
Describir las técnicas convencionales de reconocimiento de objetos basadas en
correlación, utilizando como medidas de optimización, la capacidad de discriminación
y el error de localización del objeto.
Comparar la velocidad de procesamiento para realizar el reconocimiento de objetos
con filtros de correlación en imágenes de color cuando se implementan en un ambiente
paralelo y en un ambiente secuencial.
I.4 Justificación
Debido al incremento de la resolución en las imágenes actuales, el reconocimiento de objetos
requiere mayor procesamiento, en cuyo caso, el poder de múltiples procesadores o de
múltiples núcleos puede disminuir en gran medida el tiempo de ejecución, que en el caso de la
4
programación secuencial tradicional no puede lograrse. Con el poder del procesamiento
paralelo muchos procesos pueden alimentarse en distintas unidades de procesamiento,
obteniéndose una mejora sustancial en los tiempos de ejecución, por ello, se vislumbra como
una solución para obtener el mejor desempeño de los algoritmos que requieren un gran poder
computacional.
Actualmente los equipos personales cuentan con procesadores potentes que integran más de un
núcleo de procesamiento, pero que no se utilizan de forma óptima. A pesar de que el sistema
operativo realiza las tareas administrativas sobre los programas a ejecutar, los programas que
en ese momento se ejecutan podrían estar construidos con lenguajes tradicionales que los
limitan a ejecutarse en una sola unidad de procesamiento, ignorando las demás. Este escenario
se presenta en la mayoría de los casos y en diferentes sistemas operativos.
El trabajo que se presenta en este documento tiene como objetivo presentar una solución de
programación paralela para llevar a cabo el reconocimiento de objetos con filtros
correlacionados en imágenes a color, y mostrar las ventajas y desventajas del ambiente
paralelo en cuestión.
I.5 Limitaciones y Suposiciones
Esta investigación aborda el tema del reconocimiento de objetos en imágenes utilizando filtros
de correlación, aplicando técnicas de Paralelización. Los filtros considerados son: Filtro
Espacial de Correspondencia (MSF) filtro que se deriva de la maximización de la razón señal-
ruido (SNR), Filtro Inverso (IF) se obtiene maximizando el criterio definido por la razón entre
pico y energía de correlación, Filtro de Solo Fase (POF) maximiza la eficiencia de luz y el
Filtro Optimo (OF) que minimiza la posibilidad de errores anómalos en la localización del
objeto.
Las técnicas de paralelismo analizadas se basan en las herramientas ofrecidas por MatLab
2008b, esencialmente el parfor. No se aborda la programación con la interfaz de paso de
5
mensajes (MPI). Debido a que la artquitectura utilizada para la implementación no es
adecuada para este tipo de programación
La infraestructura para realizar las pruebas considero un equipo DELL con las siguientes
características: dos procesadores Xeon de seis núcleos corriendo a una velocidad de reloj de
2.3 GHz, un bus frontal de 1066 MHz, memoria de 24 GB ECC y un disco duro de 500 GB.
El sistema operativo que ejecuta es Windows 7 a 32 bits.
El presente documento está organizado de la siguiente forma. En el capítulo II, se hace una
breve descripción de multiprocesamiento, multinúcleo, computación en Cluster, y
computación en Grid. En el capítulo III se describen los ciclos de Matlab y los principios para
cambiar un código secuencial a un código que se ejecute en paralelo en MatLab. La definición
de imagen, su procesamiento, así como los diferentes filtros gráficos de reconocimiento
basado en correlación aplicados a las imágenes, para determinar el error de localización o la
capacidad de discriminación en el reconocimiento del objeto se especifican en el Capítulo IV.
En el capítulo V, se detallan las herramientas hardware y software se utilizan para crear el
entorno de pruebas, su configuración y optimización. En el capítulo VI se analizan los
resultados de los ejercicios realizados con los filtros gráficos de reconocimiento basado en
correlación en ambiente paralelo y secuencial. Los resultados se comparan para determinar si
son los mismos. Y finalmente se resumen las conclusiones de este trabajo.
6
Capítulo II.- Antecedentes del cómputo paralelo
En este capítulo se presentan los conceptos que tienen que ver básicamente con el antecedente
del cómputo paralelo, así como las características y conceptos de las infraestructuras de
multiprocesamiento, multinúcleo, Cluster Computing y Grid Computing.
II.1 Procesamiento paralelo y distribuido.
El principal propósito del procesamiento paralelo es la de hacer los cálculos más rápidos
usando varios procesadores de manera concurrente. La búsqueda de este objetivo tenía una
tremenda influencia en todas las actividades relacionadas con la informática. La necesidad de
soluciones más rápidas y para la solución de problemas de tamaño más grandes se presenta en
una amplia variedad de aplicaciones, incluyendo los sistemas dinámicos de fluidos, la
predicción del clima, modelado simulación de grandes sistemas, extracción y procesamiento
de información, procesamiento de imágenes, inteligencia artificial y automatización de la
manufactura (JáJá, 1992).
Tres factores contribuyeron principalmente a la fuerte tendencia a favor de la computación
paralela, primero el costo del hardware ha disminuido constantemente, por lo que ahora es
posible construir sistemas con varios procesadores a un costo razonable. Segundo, la
integración a muy grande escala (VLSI) en los circuitos electrónicos ha avanzado al punto que
es posible diseñar sistemas complejos que tienen millones de transistores en un solo chip.
Tercero, las velocidades de los ciclos de reloj de los procesadores de tipo Von Neummann
parece estar llegando a los límites físicos; además de el alto rendimiento obtenido de los
procesadores secuenciales, está asociado a un incremento en los costos de forma dramática.
Todos estos factores han impulsado las investigaciones en la exploración del paralelismo y su
uso potencial en importantes aplicaciones.
La computadora paralela es una simple colección de procesadores, generalmente del mismo
tipo, interconectados en cierto modo para permitir coordinación de sus actividades y el
7
intercambio de datos. Se supone que los procesadores se encuentran a una pequeña distancia
unos de otros, y se utilizan principalmente para solucionar problemas en forma conjunta.
Contrario a esto, en las computadoras con sistemas distribuidos, pueden tener diferentes tipos
de procesadores, y estar distribuidos sobre una gran área geográfica, donde su principal
objetivo es el de usar los recursos distribuidos disponibles, recolectar información y
transmitirlo sobre la red que los interconecta (JáJá, 1992).
Las computadoras paralelas pueden ser clasificadas de acuerdo a las características de la
arquitectura y los modos de operación. En particular, estos criterios incluyen los tipos y
números de procesadores, la interconexión entre los procesadores y el correspondiente
esquema de comunicación, el total control de la sincronización, y las operaciones de
entrada/salida.
En los recientes años, la computación distribuida y el cómputo paralelo han evolucionado en
tal forma que prometen ser la solución para las necesidades de cómputo en el futuro. Los
avances significativos en los algoritmos paralelos y en las arquitecturas computacionales han
demostrado tener el potencial para aplicar la computación concurrente en una gran variedad de
problemas. Los ejemplos más representativos de la computación distribuida son: el Cluster y
el Grid.
Las tecnologías de Cluster y Grid representan diferentes maneras de resolver problemas de
forma eficiente. Aunque difieren en su estructura, las diferentes características y beneficios
son complementos de los dos, por ejemplo, un Cluster puede contribuir con recursos a un Grid.
II.1.1 Multiprocesamiento
Una tendencia significativa en el campo de la computación, es atacar problemas que requieren
mayor poder computacional minimizando tiempos en la solución de un problema determinado,
esta necesidad ha llevado a la construcción de computadoras que contienen más de un
procesador trabajando conjuntamente. El multiprocesamiento se ha utilizado en los sistemas
8
durante varias décadas, pero está siendo de nuevo objeto de interés debido a los bajos costos
que representan los procesadores actuales. En lugar de incrementarse la frecuencia del reloj
para obtenerse velocidades cercanas a 0.0001ns, es más factible incrementar la cantidad de
procesadores y construir una computadora con 1000 procesadores con velocidades de 1ns.
Aunque el segundo sistema es más lento comparado con el primero, en teoría el poder de
cómputo es el mismo (Andrew S. Tanenbaum y Goodman, 2000).
El multiproceso para tareas generales es, a menudo, difícil de conseguir, debido a que pueden
existir varios programas manejando datos internos a la vez, conocido como estado o contexto
(Huerta Pellitero, 2009). Los programas típicamente se escriben asumiendo que sus datos son
incorruptibles. Sin embargo, si otra copia del programa se ejecuta en otro procesador, las dos
copias pueden interferir entre sí intentando ambas leer o escribir su estado al mismo tiempo.
Para evitar este problema se usa una variedad de técnicas de programación incluyendo
semáforos, algunas comprobaciones y bloqueos que permiten a una sola copia del programa
cambiar de forma exclusiva ciertos valores (Andrew S. Tanenbaum, 2003).
II.1.1.1 Sistemas multiprocesamiento
Tradicionalmente el multiprocesamiento es conocido como la ejecución de múltiples procesos
de forma simultánea, asignándole a cada proceso un CPU y realizando las tareas de forma
más rápida. Múltiples procesadores pueden ser utilizados para ejecutar múltiples instrucciones
de software dentro de un proceso único.
Cuando se habla de múltiples procesadores, se hace referencia a una computadora que
contiene más de un procesador central, y que cada uno puede ejecutar al menos una tarea
diferente de forma independiente. Con la aparición del multiprocesamiento, el procesador deja
de ser el recurso más valioso del sistema, y toman su lugar los temas de confiabilidad,
paralelismo en computación, esquemas óptimos de conexión y contención entre procesadores
que intentan acceder los mismo recursos (Deitel, 1985).
9
II.1.1.2 Confiabilidad.
Uno de los atractivos de los sistemas de multiprocesamiento es que si un procesador falla, los
procesadores que siguen funcionando continúan operando, claro que esto no es automático y
requiere de un diseño cuidadoso. Cuando un procesador falla es importante que los demás
sean notificados, el sistema operativo debe ser sensible y detectar el fallo del procesador
reajustando sus parámetros de asignación de recursos y tomar así una acción de balance entre
los procesadores activos evitando la sobrecarga del sistema (Hennessy y Patterson, 1993).
El modelo de multiprocesador se extiende al software, ya que todos los procesos que se están
ejecutando pueden compartir un solo espacio virtual de direcciones mapeado en la memoria
común, y cualquier proceso puede leer o escribir en la memoria, no se necesita más, los dos
procesos se pueden comunicar haciendo que uno de ellos escriba y que el otro los lea después.
Esta capacidad de comunicar los dos procesos es la razón de que los sistemas
multiprocesadores sean tan populares (Andrew S. Tanenbaum y Goodman, 2000) y es un
modelo fácil de entender y que puede aplicarse a una gran gama de problemas. Como ejemplo
sería un programa que examina una imagen y enumera todos los objetos que contiene, y donde
cada procesador puede analizar una sección de la imagen, sin embargo, todos los procesos
tiene acceso a la imagen completa, debido a que un objeto puede ocupar varias secciones
como se puede observar en la Figura 1 (Andrew S. Tanenbaum y Goodman, 2000).
Figura 1: a) Multiprocesador con 16 CPU que comparten una misma memoria; b) imagen dividida en 16 secciones, cada una de las cuales se analiza con una CPU distinta.
10
II.1.1.3 Paralelismo en computación
Se mencionan dos clasificaciones para el paralelismo:
a) Paralelismo Funcional, se aprovecha cuando las funciones, bloques, instrucciones, entre
otras, bien iguales o distintas que intervienen en la aplicación, se ejecutan en paralelo.
Ejemplos de estos sistemas son: MIMD, MISD (véase Sección II.1.1.6).
b) Paralelismo de Datos, el cual se consigue mediante el uso de estructuras de datos que
permiten operaciones paralelas sobre sus elementos, se explotan cuando una misma función o
instrucción se ejecuta repetidas veces en paralelo con diferentes datos. Ejemplos de estos
sistemas son: SIMD, MIMD-SPMD ( véase Sección II.1.1.6 ).
II.1.1.4 Arquitecturas paralelas y Aplicaciones
Como se menciona anteriormente, en la aparición de las computadoras los procesadores eran
muy lentos comparados con los actuales, el poder de cómputo era limitado, pero en su época
las soluciones que brindaron fueron increíbles. La computación comenzó a diversificarse y
orientarse a distintas áreas de aplicación, siendo las áreas de investigación las que más poder
computacional demandaban. El tratamiento de datos es un ejemplo, así como los procesos de
predicción del clima y los procesos de reconocimiento de patrones en imágenes.
Los procesadores funcionaban a velocidades muy bajas comparadas con las velocidades
logradas en la actualidad, los buses de datos que intercomunicaban los periféricos de
entrada/salida eran principales cuellos de botella. Actualmente los procesadores han alcanzado
velocidades de hasta 3.6 GHz y algunos osados, han modificado las frecuencias de reloj por
encima de las velocidades especificadas (overclock) del procesador, con la finalidad de
obtener ganancias en velocidad a pesar de comprometer la integridad del mismo procesador.
Además los buses de datos han sido optimizados para proporcionar mayores velocidades de
transferencia.
11
El poder de procesamiento que se ha logrado en los nuevos diseños de procesadores es
sorprendente, sin embargo, es insuficiente para áreas de investigación, videojuegos o
tratamiento de imágenes y video, llevando a la industria a buscar alternativas para incrementar
el poder de cómputo y atacar estas necesidades. Las marcas líderes en el mercado de
componentes de hardware y en exclusiva de procesadores, integraron en sistemas de cómputo
varios procesadores trabajando de manera simultánea en diferentes arreglos para poder ofrecer
una solución en particular. Como ejemplos pueden mencionarse las Workstation, Servidores
de red, o los equipos de la empresa Silicon Graphics International (SGI) orientadas a video,
imagen y modelado 3D (Figueria, 1996).
Los fabricantes de procesadores en busca de este poder de cómputo, integraron más de un
núcleo de procesamiento en un solo encapsulado, dando origen a los procesadores multinúcleo
también conocidos como multicore. Todas las arquitecturas multinúcleo están basadas en los
mismos principios establecidos para los sistemas multiprocesadores, teniendo una memoria
principal que es compartida y pueden contener memoria caché de niveles L1, L2, L3 donde se
guardan una serie de datos para su rápido acceso. El cache L1 es conocido como caché interno
más cercano a la CPU con la misma velocidad del núcleo y de tamaño reducido; memoria
cache L2 interna es de mayor tamaño, con una velocidad menor al núcleo y, memoria cache
L3 que es de mayor tamaño a las anteriores y que se accede de forma compartida. En la Figura
2 se muestra la estructura de un procesador multinúcleo (Tian y Shih, 2009). El tema del
multinúcleo es abordado en la Sección II.1.2.
Figura 2: Estructura de un procesador multinúcleo
12
II.1.1.5 Modelos multiprocesadores de Von Neumann
El matemático John Von Neumann, definió una arquitectura de multiprocesadores a partir de
su modelo de un procesador. En la Figura 3 se observa cómo puede incrementarse el número
de procesadores compartiendo una única memoria.
El modelo en la Figura 3(a), funciona de la siguiente manera: la memoria es utilizada para
almacenar el programa como los datos que necesita para ejecutarse y el programa son datos
conocidos como instrucciones codificados que indican al procesador qué tarea va a realizar.
Los datos del programa son información que utiliza el programa, el procesador obtiene las
instrucciones y los datos de la memoria para ejecutarlos de forma secuencial. El objetivo
principal de un sistema multiprocesador, es acelerar la ejecución de aplicaciones
(Supercomputación) y ejecutar más aplicaciones por unidad de tiempo, que es el caso de la
Figura 3(b) (Hennessy y Patterson, 1993).
II.1.1.6 Taxonomía de Flynn
Flynn en 1966, observando los flujos de las instrucciones y datos exigidos por las
instrucciones, propuso un modelo sencillo para clasificar las computadoras en cuatro
categorías (Hennessy y Patterson, 1993):
(a)
MEMORIA
PROCESADOR
E/S
MEMORIA
PROCESADOR 1
E/S
PROCESADOR 2
PROCESADOR 3
PROCESADORN
(b)
Figura 3: a) Modelo original de un procesador, b) Modelo multiprocesador
13
SISD (Single Instruction, Single Data – Flujo único de instrucciones, flujo único de datos).
SIMD (Single Instruction, Multiple Data – Flujo único de instrucciones, flujo múltiples de
datos).
MISD (Multiple Instruction single Data – Flujo múltiple de instrucciones, flujo único de
datos) .
MIMD (Multiple Instruction Multiple Data – Flujo múltiple de instrucciones, flujo
múltiples de datos ) .
En la Tabla I se organizan las categorías propuestas por Flynn de acuerdo a las instrucciones y
datos que atienden.
Tabla I: Taxonomía de Flynn
Instrucciones
Datos
Una Instrucción Múltiples
Instrucciones
Un dato SISD MISD
Mútiples Datos SIMD MIMD
II.1.1.6.1 Flujo único de instrucciones, flujo único de datos (SISD)
Este modelo no explota el paralelismo en la ejecución de las instrucciones, ni en el flujo de
datos, en la Figura 4 se puede observar que el único procesador atiende una instrucción y un
solo flujo de datos obteniendo un solo resultado al final de la secuencia de instrucciones. En
este modelo se clasifican las máquinas con un solo procesador como las PC.
Leer A Leer B C=A+B A=B*2
Ejecución Tiempo
CPU
Instrucción
Resultado Datos
Figura 4: Modelo SISD
14
II.1.1.6.2 Flujo único de instrucciones, flujo múltiples de datos
(SIMD)
Este modelo explota varios datos dentro de un único flujo de instrucciones para realizar las
operaciones que se pueden ejecutar al mismo tiempo. Un ejemplo puede ser que un equipo
SIMD, podría tener 64 flujos de datos simultáneamente hacia 64 Unidades Aritméticas
Lógicas (ALU) para formar 64 sumas de manera simultánea, en un ciclo de reloj.
La característica principal de SIMD es que todas las unidades de ejecución paralela están
sincronizadas y responden a una instrucción (véase Figura 5). Las instrucciones SIMD se
difunden a todas las unidades de ejecución, donde cada una mantiene su propio conjunto de
registros. Las máquinas SIMD masivamente paralelas cuentan con redes de interconexión
para intercambiar datos entre los elementos de procesamiento.
La arquitectura SIMD es adecuada para las instrucciones vectoriales, como son los
tratamientos de arreglos en ciclos for, por consiguiente, tener oportunidad de paralelismo
masivo, también requiere cantidades masivas de datos o paralelismo en datos. Esta
arquitectura presenta una gran debilidad en instrucciones “case”, debido a que cada unidad de
procesamiento debe realizar una operación diferente sobre su dato, dependiendo del dato que
Resultado Resultado
Resultado Datos
CPU
CPU
CPU
CPU(n)
Datos Datos
Datos Resultado
Instrucción
Ejecución Tiempo
Leer A(1) Leer B(1) C(1)=A(1)+B(1)
Procesador 1
Leer A(2) Leer B(2) C(1)=A(2)+B(2) Procesador 2
Leer A(3) Leer B(3) C(1)=A(3)+B(3)
Procesador 3
Leer A(n) Leer B(n) C(1)=A(n)+B(n)
Procesador n
Figura 5: Modelo SIMD
15
tenga. Aquellas unidades que tengan un dato erróneo inhabilitan para permitir que el resto
puedan continuar. Estas situaciones, esencialmente se ejecutan a 1/n del rendimiento, donde n
es el número de cases (Hennessy y Patterson, 1993).
II.1.1.6.3 Flujo múltiple de instrucciones, flujo único de datos (MISD)
Este modelo no es tan común en la actualidad debido a que múltiples instrucciones
generalmente tratan a múltiples flujos de datos, por lo que se utiliza donde se requiere tener
varios sistemas de respaldo previendo fallos en sistemas críticos. No se ha llegado a producir
en forma masiva (Hennessy y Patterson, 1993; Quinn, 2004).
Es difícil imaginar este modelo sin la Figura 6. Un flujo múltiple de instrucciones con un flujo
múltiple de datos es más fácil de imaginar que múltiples instrucciones con un flujo único de
datos.
II.1.1.6.4 Flujo múltiple de instrucciones, flujo múltiple de datos
(MIMD).
En la Figura 7 se observan varios procesadores autónomos que ejecutan instrucciones
diferentes, sobre datos distintos. Los sistemas distribuidos suelen incluirse en esta
CPU
Instrucciones
Resultado Resultado
Resultado
CPU
CPU
CPU(n)
Datos Resultado
Instrucciones Instrucciones Instrucciones
Ejecución Tiempo
Leer A(1) C(1)=A(1)*1 Store C(1)
Procesador 1
Leer A(1) C(2)=A(1)*2 Store C(2)
Procesador 2
Leer A(1) C(3)=A(1)*3 Store C(3)
Procesador 3
Leer A(n) C(n)=A(n) *n Store C(n)
Procesador n
Figura 6: Modelo MISD
16
clasificación, donde la construcción de una computadora potente se conecta a otras
computadoras más pequeñas por parte del usuario, es decir, se agregan tantas CPUs como
puedan comprarse para obtenerse un rendimiento proporcional. Otra ventaja de MIMD puede
ser, un alto rendimiento absoluto, más rapidez que si se tuviera un procesador más grande, y la
más alta fiabilidad y disponibilidad debido a la redundancia.
Hacia los años 80’s se hace una definición del concepto de Multis como una nueva clase de
computadoras basadas en múltiples microprocesadores. El pequeño tamaño, el bajo costo y
alto rendimiento de los microprocesadores permiten el diseño y construcción de estructuras de
computadoras que ofrecen ventajas significativas en fabricación, relación precio-rendimiento,
y fiabilidad sobre las familias de computadoras tradicionales (Bell, 1985).
Los Sistemas MIMD se clasifican en tres categorías de acuerdo a la forma como los
procesadores utilizan la memoria para gestionar datos:
a) Memoria Compartida: Los procesos tienen acceso a la misma localidad de memoria
física. Los procesos pueden ejecutarse en un solo procesador. Además, los procesos
también pueden ejecutarse en procesadores distintos y acceden a la misma localidad
Figura 7: Modelo MIMD
Ejecución Tiempo
Leer A(1) Leer B(1) C(1)=A(1)+B(1) Store C(1)
Procesador 1
Call funA X = Z * A Store X
Procesador 2
Leer F(1) G=F(1)*F(1) Store G
Procesador 3
Y= 1 For I= 1 to 10 Y = Y*I Store Y
Procesador n
CPU Datos
Instrucciones
Resultado Resultado
Resultado
CPU
CPU
CPU(n) Resultado
Instrucciones Instrucciones Instrucciones
Datos Datos Datos
17
de memoria física, en este supuesto se debe tener especial cuidado con la consistencia
de datos, por tal motivo se usan mecanismos como semáforos, barreras entre otros para
lograr esta consistencia.
b) Memoria Distribuida: Cada procesador tiene su memoria exclusiva, si un procesador
necesita un dato que se encuentra en una localidad de memoria remota, debe solicitarlo
para poder accederlo. Dentro de esta clasificación se tienen a las definiciones UMA
(Uniform Access Memory), NUMA (Non Uniform Access Memory), COMA (Cache
Only Memory Access) (Dandamudi, 2003; Figueria, 1996)
c) Memoria Compartida Distribuida: En este modelo existe una capa de software que crea
un espacio de memoria virtual compartida, cada procesador aporta un espacio de
memoria para su creación.
II.1.2 Multinúcleo
La necesidad de lograr un mayor rendimiento sin aumentar el consumo de energía y el calor,
se ha convertido en una gran preocupación crítica para muchas compañías de Tecnologías de
Información. La solución propuesta ha sido diseñar nuevas arquitecturas de procesadores que
integran dos o más núcleos de procesamiento en un procesador único que prometen mejorar el
rendimiento y minimizar la generación calor, pues cuando a un procesador se le exige mayor
velocidad se demanda mayor energía (Ortega Lopera, 2009), lo que incrementa la cantidad de
calor disipado.
Históricamente las manufacturas de los procesadores han respondido a la solicitud de mayor
potencia, principalmente para lograr mayores velocidades se han incrementado las frecuencias
del reloj, sin embargo, el tema de la temperatura y refrigeración han sido pivotes principales
para revaluar el diseño de los procesadores.
18
La otra forma para lograr un mayor rendimiento en los procesadores es reducir la velocidad
del reloj e incrementar la cantidad de unidades de procesamiento (agregar más núcleos de
procesamiento), en consecuencia se obtiene menor cantidad de calor y mayor eficiencia,
afectando positivamente a la vida útil de los componentes electrónicos de los sistemas.
II.1.2.1 Aprovechamiento de la Tecnología Multithreading y
(Multitarea).
El estándar de la industria en servidores que utilizan múltiples procesadores desde hace varios
años hace uso del Multithreading, que permite que las aplicaciones en red tomen ventaja de los
procesadores adicionales, múltiples hilos de ejecución de software. Estas capacidades han
permitido a las organizaciones obtener aplicaciones con un gran desempeño (Fruehe, 2005).
A diferencia de la multitarea, que es la capacidad de poder ejecutar varios programas
diferentes al mismo tiempo en un procesador o sobre varios.
II.1.2.2 Optimización de las Aplicaciones de Software
La optimización de software puede ser un eficiente camino para obtener un mejor desempeño
sin incrementar el consumo energético y la disipación de calor. Existen herramientas
(Compiladores Intel) para compilación que permiten optimizar de forma considerable el
rendimiento del software, obteniendo ventaja sobre el software que no las utilizan. Estos
rendimientos están limitados a la configuración de un sistema específico y el entorno de la
aplicación (Fruehe, 2005).
II.1.2.3 Potencial de escalabilidad de los procesadores multinúcleo
Anteriormente cuando un sistema de cómputo contaba con equipos que contenían un solo
socket para un procesador, sólo proveían acceso a un núcleo de procesamiento, sin embargo,
este enfoque cambió en los últimos años, donde sistemas con un socket para un procesador,
19
permiten tener acceso a dos, cuatro o más núcleos de procesamiento, tendencia que se seguirá
en un futuro donde un procesador físico va a contener cada vez más núcleos de procesamiento
(Hernández Barragán y Jorba Esteve, 2010).
Las soluciones que hacen de uso de procesadores con tecnología X86 (AMD-x86, Intel
EM64T, Intel Core) según la lista Top500.org (2011) al mes de junio suma 89.4% del total
(véaseTabla II), mostrando claramente la tendencia hacia el uso de procesadores con esta
arquitectura.
Tabla II: Uso de procesadores con tecnología X86 en la lista top500.org
Familia de procesador Conteo Porcentaje %
Power 45 9.00 % NEC 1 0.20 % Sparc 2 0.40 % Intel IA-64 5 1.00 % Intel EM64T 380 76.00 % AMD x86_64 66 13.20 % Intel Core 1 0.20 % Totales 500 100%
En la Figura 8 se observa la tendencia hacia el uso de sistemas multinúcleo de más de 4
núcleos en forma masiva, lo que lleva a tomar en cuenta nuevos elementos al momento de
realizar evaluaciones de desempeño, los nuevos aplicativos, especialmente a los que afectan de
manera directa el trabajo de procesos en paralelo, la distribución de cargas y la sincronización
de datos entre los diferentes núcleos (Hernández Barragán y Jorba Esteve, 2010).
Las estructuras multinúcleo deben siempre incluir módulos de caché. Los desarrollos actuales
de los procesadores multinúcleo pueden variar de acuerdo al fabricante, ya que pueden incluir
módulos de cache independiente o compartida, implementaciones de bus y adicionalmente
capacidades de manejar hilos (threats en inglés) como la tecnología Hyper-Threading (HT)
Technology de Intel.
20
Figura 8: Número de núcleos x Procesador
Como se ha mencionado anteriormente, el incremento de núcleos dentro de un encapsulado de
un solo procesador permite obtener un excelente rendimiento mientras se logra reducir el
consumo energético reduciendo las velocidades de reloj en cada uno de los núcleos.
Fruehe (2005) compara dos configuraciones de servidor, en una se utilizan dos procesadores
independientes con frecuencias de reloj a 3.6 GHz (véase Figura 9 ), mientras que en la otra
configuración se utilizan dos procesador multinúcleo con frecuencias de reloj a 2.8 GHz. En
ésta última, se visualiza un mayor rendimiento a diferencia de los procesadores de alta
velocidad (véase Figura 10). Estas estimaciones se basaron solamente con modelos técnicos y
es una muestra del porqué la industria comienza a migrar de sistemas basados en un solo
procesador a sistemas multi-núcleo.
21
Figura 9: Desempeño efectivo de dos procesadores mono núcleo a 3.6 GHz de velocidad
Figura 10: Desempeño efectivo de dos procesadores multi núcleo a 2.8 GHz de velocidad
Existen varios factores que pueden influir en el rendimiento real y la escalabilidad del
procesador, y estos, generalmente están ligados a una gran cantidad de variables de la
plataforma y el medio ambiente de la aplicación. Entre los factores que pueden afectar la
ampliación interna de múltiples núcleos están: el compilador, consideraciones arquitectónicas,
la memoria, los periféricos de I/O, bus frontal, entre otras (Fruehe, 2005).
22
II.1.2.4 Tecnologia Hyper-Threading® (HT).
Para mejorar el rendimiento del procesador, en el pasado se crearon los subprocesos en los
programas, dividiendo las instrucciones en varias transferencias para que varios procesadores
pudieran actuar sobre ellas. La tecnología Hyper-Threading®, proporciona un paralelismo a
nivel de subprocesos en cada procesador, lo que da como resultado un uso más eficaz de los
recursos, mayor capacidad de procesamiento y rendimiento mejorado en el software con
subprocesos múltiples (Intel Corporation 2011).
Para explotar la tecnología Hyper-Threading® de Intel es necesario contar con un procesador
Intel® con esta tecnología y un chipset que la soporte. El sistema operativo juega un papel
importante, debido a que debe de incluir optimizaciones para dar soporte a la tecnología
Hyper-Threading® y una BIOS compatible para poder brindar la flexibilidad y rendimiento
del sistema incrementados.
A pesar que esta tecnología fue creada por Intel para los procesadores Pentium 4, el Hyper-
Threading® (HT) está disponible en procesadores multinúcleo, permitiendo a cada núcleo
funcionar como si se tratara de dos procesadores. Con la tecnología HT, las aplicaciones de
software para servidor con subprocesos múltiples pueden ejecutar subprocesos en paralelo con
cada núcleo en una plataforma de servidor.
Las ventajas que ofrece esta tecnología son (Intel Corporation 2011):
Permite más soporte de usuario, mejorando la productividad empresarial.
Ofrece tiempos de respuesta más rápidos para Internet y aplicaciones de comercio
electrónico, mejorando las experiencias de los clientes.
Aumenta el número de transacciones que se pueden procesar.
Permite compatibilidad con sistemas operativos y aplicaciones IA-32 existentes.
Gestiona mayores volúmenes de trabajo.
23
II.1.3 Cluster Computing (Computación en Cluster)
Este término pertenece a los sistemas denominados de computación distribuida, y
específicamente a los que corresponden a servicios de una red local. Desde la aparición de los
Cluster, se han ido sustituyendo las supercomputadoras, hasta conformarse como sistemas con
un alto poder procesamiento que no implica costos elevados (Sánchez Enriquez, 2007).
Los sistemas de Cluster se han popularizado a tal grado, que en la actualidad se pueden
encontrar en centros de investigación, escuelas y en algunas empresas del área privada.
Pérez (2007) define un Cluster como la capacidad de varias máquinas para realizar una tarea
como si se tratara de una única máquina. Sánchez Enriquez (2007) lo define como: un
conjunto de computadoras interconectadas con dispositivos de alta velocidad que actúan en
conjunto usando el poder cómputo de varios CPUs en combinación para resolver ciertos
problemas dados.
Como se puede observar, los conceptos establecen que son un conjunto de computadoras
interconectadas conocidos como nodos, que trabajan en la resolución de un problema dado,
proporcionando para esta tarea los recursos con los cuales cada nodo cuenta para lograr el
objetivo.
II.1.3.1 Componentes
Se utiliza un Cluster para la construcción de una supercomputadora que funciona como un
servidor en una arquitectura de Cliente – Servidor, con el cual se reducen los costos de
inversión.
La construcción de los Cluster es fácil, además, no representa un alto costo en su integración,
debido a la flexibilidad de los componentes, estos pueden ser hardware y software heterogéneo,
hardware y software homogéneo o una combinación de ambos (Sánchez Enriquez, 2007).
24
Los componentes de un Cluster son:
a) Nodos: los nodos se consideran a los puntos terminales, que pueden ser computadoras,
Workstation o Estaciones de trabajo o computadoras de múltiples procesadores.
b) Sistema Operativo: Es todo sistema base con soporte para multiprocesamiento o
multiusuario que facilite el trabajo de comunicación y acceso eficaz de los recursos.
Entre los sistemas operativos más usados en estos sistemas figuran Linux con Open
Mosix, Rocks una distribución especializada en Clustering, Unix con Solaris, HP-Ux y
Aix. Microsoft Windows con Windows NT/2000/2003 Server. Apple con su sistema
operativo OS X y algunos sistemas operativos construidos especialmente para un
Cluster específico.
c) Conexiones de Red: El Cluster se construye sobre una red de área local y el protocolo
Ethernet para comunicar las computadoras personales que forman el Cluster.
d) Middleware: Capa de software que se encuentra entre los sistemas operativos y el
usuario.
e) Protocolos de Comunicación y Servicios: Entre los protocolos de comunicación más
utilizados en los Cluster es el TCP/IP y UDP pero pueden ser utilizado algunos más.
f) Aplicaciones: Son las aplicaciones que dan soporte al Middleware o se ejecutan sobre
él, las aplicaciones de usuario.
II.1.3.2 Cluster Beowulf
Donald Becker y Thomas Sterling en 1994 construyeron el primer Cluster con fines de
investigación basado en Linux (Plaza Nieto, 2003), al cual denominaron Beowulf. El Cluster
Beowulf no es más que una colección de computadoras personales (PC’s) sin componentes
especiales, conectadas por medio de una red privada de alta velocidad. En la Figura 11, se
puede apreciar la configuración. El servidor Beowulf es el que administra los trabajos en el
Cluster. Las aplicaciones que se ejecutan dentro de Cluster deben implementar características
25
que permitan su control y ejecución utilizando librerías de paso de mensajes como la MPI1 o
PVM2.
Figura 11: Representación gráfica de un Cluster Beowulf
II.1.3.3 MPI (Message Passing Interface)
MPI es un estándar portable para la programación paralela principalmente en sistemas
distribuidos. MPI usa el paradigma del paso de mensajes y está bien adaptado para trabajar en
máquinas con memoria distribuida y por supuesto, el paso de mensajes puede ser usado en
memoria compartida por múltiples procesadores. El estándar MPI define la sintaxis y
semántica de más de 125 funciones para facilitar que las aplicaciones con pase de mensajes
sea portable (MPI-Forum, 2009).
1 Message Passing Interface – Interface de Pase de Mensajes 2 Parallel Virtual Machine – Máquina Virtual Paralela
26
MPI permite dividir las tareas fácilmente en grupos para realizar esas partes de procesamiento,
contiene también recursos para realizar la comunicación de uno a muchos o de muchos a
muchos, esto da la posibilidad al programador de ordenar las tareas en una topología virtual.
II.1.3.4 PVM (Parallel Virtual Machine)
PVM es un paquete de software que permite a una red de computadoras, compartir los
recursos como la memoria y el procesador, como una única máquina de forma virtual, este
paquete consta de dos partes (Universidad de Talca, 2007): un proceso o demonio que
cualquier usuario puede instalar en la máquina, y una librería que contiene las rutinas para
inicializar tareas en otras máquinas que ejecutan el proceso, comunicación entre tareas y
cambios de configuración.
Las bibliotecas y funciones del PVM (Dandamudi, 2003) ofrecen un completo repertorio de
primitivas, entre ellas, funciones para enviar y recibir mensajes, iniciar procesos, coordinar
tareas y modificar la máquina virtual.
II.1.3.5 Cluster Mosix
El Cluster Mosix básicamente actúa más a nivel del sistema operativo, que a nivel de la
aplicación, en otras palabras son parte del kernel. Finalmente las aplicaciones se montan sobre
esta capa y se ejecutan de manera distribuida sobre una gran cantidad de equipos sin necesidad
de hacer cambios en las aplicaciones, Figura 12, con MOSIX se obtiene una capa adicional
sobre la cual los procesos corren en diversas computadoras, cada proceso es atendido por una
computadora, se hace un balance de carga derivando cada proceso nuevo a la computadora con
menos carga.
El núcleo de MOSIX está formado por algoritmos que monitorean y dan repuesta a las
actividades requeridas del Cluster mediante migración automática de los procesos a los nodos
mejor capacitados.
27
La utilización de cada uno de estos dos tipos de clusters va de acuerdo al problema a resolver,
por ejemplo, si el problema implica muchos procesos pequeños, entonces sería más sencillo
resolverlo con un Cluster tipo MOSIX, pero si al contrario, se trata de un solo proceso que
necesita una gran cantidad de poder de cómputo, lo indicado sería la utilización de un Cluster
Beowulf, lo que implica el desarrollo de la aplicación respectiva utilizando librerías de MPI o
PVM.
Figura 12: Representación gráfica de un Cluster MOSIX
II.1.4 Grid Computing (Computación en Grid)
El Grid Computing surge con la necesidad de ampliar la potencialidad de las computadoras de
todo el mundo sin necesidad de aumentar la capacidad de procesamiento, integrar las
estaciones de trabajo local para formar una sólida y potente Grid mundial y procesar tareas
con el más alto poder computacional, la Figura 13 representa un Grid mundial. Los Grid se
fundamentan en teorías sólidas que actualmente siguen en investigación. Muchas de estas
teorías son producto de estudios de los problemas asociados a los clusters de computadoras, y
otras a la extensión del Internet a su más alta capacidad de aprovechamiento de los nodos
conectados a la red (Avila George, 2010; Cabrillo Bartolome, 2008).
28
La evolución de Grid Computing se refleja en el avance de la estandarización de esta
tecnología (el estándar de Globus Project es el estándar de facto) donde se encuentra definida
la arquitectura del Grid, los niveles de acceso, los requisitos, los servicios, entre otros.
Figura 13: Representación gráfica de un Grid (Tomada de www.gridcafe.org)
El Grid Computing al igual que el clustering, se enmarca dentro de las tecnologías de
computación distribuida, englobando conceptos de sistemas distribuidos, programación
multiprocesador, redes de computadoras, seguridad, base de datos, entre otros.
Grid computing es una tecnología que permite de compartir la potencia computacional,
aprovechando los ciclos de procesamiento no utilizados de cada nodo que pertenecen al Grid.
Con esto se busca enfrentar problemas que antes sólo eran enfrentados por grandes
supercomputadoras de entidades gubernamentales, universidades o grandes empresas
multinacionales; y aun más, la idea es tener una variedad de nodos en todo el mundo donde se
podrían resolver tareas que demande un gran poder de cómputo y/o almacenamiento (Sánchez
Enriquez, 2007).
29
II.1.4.1 Características de Grid Computing
El Grid computing cuenta con las siguientes características:
Balanceo de Sistemas: No hay necesidad de calcular la capacidad de los sistemas en
función de los picos de trabajo, debido a esto, la capacidad puede reasignarse desde la
granja de recursos donde se necesite.
Alta Disponibilidad: Si un nodo falla, los servicios son reasignados entre los demás
nodos restantes.
Reducción de Costos: Los recursos se gestionan por granjas de recursos, y no por
grandes servidores, esto hace que se usen componentes de bajo costo.
II.1.4.2 Arquitectura
La arquitectura del Grid es abierta y se basa en un estándar que facilita la extensibilidad,
interoperabilidad y portabilidad. El Grid es una arquitectura de protocolos, debido a que se
definen los mecanismos que permiten a los usuarios y recursos negociar, establecer, gestionar
y explotar los recursos compartidos, dando posibilidad de utilizar los recursos de
procesamiento propios sin tener que adquirir capacidad extra de procesamiento.
La arquitectura del Grid presenta 5 niveles, el de infraestructura, conectividad, recurso,
recursos, y aplicaciones (Cabrillo Bartolome, 2008; Sánchez Enriquez, 2007).
II.1.4.3 Nivel Infraestructura
Aquí se localizan los recursos computaciones como son: computadoras, clusters,
supercomputadoras, almacenamiento, red, entre otras.
II.1.4.4 Nivel Conectividad
30
Este nivel incluye los protocolos de comunicación: TCP/IP, SSL, etc. Así como los nuevos
protocolos en fase de desarrollo para mejorar la velocidad y seguridad en la red.
II.1.4.5 Nivel Recurso
Se toma el recurso general y que permite tener la información y control sobre el mismo,
tomando en cuenta características técnicas, la carga actual y los protocolos para controlar el
recurso, el acceso, arranque del proceso la gestión.
II.1.4.6 Nivel Recursos
Se engloban en este nivel todos los servicios que van a permitir gestionar un conjunto de
recursos: servicios de directorios, manejadores distribuidos, monitorización, el diagnóstico de
la ejecución de las tareas y acceso a datos distribuidos.
II.1.4.7 Nivel Aplicaciones
Este nivel se concentra en la definición de los protocolos que permiten a las aplicaciones
acceder al Grid a través de los distintos niveles e infraestructura.
II.1.4.8 Desventajas
- El Grid aún no ha alcanzado su máximo desarrollo, debido a la deficiencia en seguridad y
escalabilidad que siguen mostrando los proyectos de Grid Computing.
- No toda aplicación es conveniente, algunos tipos de aplicación no pueden ser puestos en
forma paralela o distribuida, el problema es cómo decidir cual si y cual no.
- La configuración de un Grid puede que afecte la calidad, la fiabilidad, y seguridad de una
infraestructura de organización de un Grid.
31
32
Capítulo III.- Cómputo paralelo en MatLab.
MatLab (MATrix LABoratory) es un software matemático que ofrece un lenguaje de
computación técnico de alto nivel denominado M, y un entorno de desarrollo (IDE) con
ambiente interactivo para desarrollo de algoritmos, análisis de datos y computación numérica.
Con este software se pueden resolver problemas de computación de forma más rápida que la
programación tradicional en lenguajes tradicionales como C, C++ o Fortran (MathWorks,
2011c).
MatLab se puede utilizar en gran variedad de áreas, incluyendo comunicaciones, control,
análisis y modelos financieros, algoritmos genéticos, señales, procesamiento de imágenes,
cómputo en paralelo, entre otras. Debido a que contiene una gran colección de funciones con
propósitos específicos, organizadas y separadas en cajas de herramientas o ToolBoxes. De
acuerdo al área de aplicación, permite el desarrollo de programas con más rapidez, además de
contener una serie de características para documentación, el código se puede integrar con otros
lenguajes como C y Fortran.
MatLab cuenta con las siguientes características (MathWorks, 2011c):
Lenguaje de computación de alto nivel.
Ambiente de desarrollo para manejo de código, archivos y datos.
Herramientas para la exploración interactiva , diseño y depuración
Funciones matemáticas para algebra lineal, estadística, análisis de Fourier, filtros,
optimización e integración numérica.
Las opciones para la programación en paralelo con sesiones interactivas ofrecidas por MatLab
se pueden ejecutar de dos maneras:
Pmode: dispone de una interfaz grafica de usuario (GUI) y solo es para sesiones interactivas.
33
Matlabpool: Permite sesiones interactivas y trabajo de proceso por lotes (Batch)
Los paradigmas paralelos utilizados para la programación en paralelo con MatLab se
clasifican en (MathWorks, 2011a):
Spmd (programa simple, múltiple datos): Es el equivalente a pmode, pero sin la ventana
individual para cada sesión de trabajo, cada tarea asignada a cada procesador es numerada con
un índice.
Drange: Debe ser usado con pmode ó matlabpool + spmd. La distribución de tareas es
controlada por el indice del bucle. Las variables o vectores predefinidas en el cliente son
accesibles como locales en las sesiones de trabajo.
parfor: Es similar a drange en cuanto a que las tareas son distribuidas según el índice del bucle.
Existen algunas diferencias, parfor no trabaja en el entorno de spmd, parfor permite
operaciones de reducción, como las sumas que requieren comunicación entre las sesiones de
trabajo.
34
Por tal motivo parfor se considera una operación de datos paralelos, mientras que drange es
una operación de tareas paralelas, parfor permite más opciones de paralelización, por tal
motivo es el utilizado en este trabajo.
III.1 Ciclos
Todo lenguaje de computación requiere en un momento ejecutar una serie de instrucciones
que son repetitivas, los ciclos permiten al programador especificar qué segmento de código es
el que debe de repetirse secuencialmente n cantidad de veces (iteraciones), esto ayuda a
reducir la cantidad de líneas escritas y hacer más entendible el código.
MatLab cuenta con instrucciones que permiten usar ciclos, estas son: while y for. Para el
desarrollo del trabajo presentado en este documento, es importante centrarse en el ciclo “for”,
debido a que tiene una variante en Matlab, que es el parfor y que permite ejecutar el segmento
de código que se repetirá de forma concurrente, es decir, en más de un procesador o núcleo, si
es que se cuenta con más de uno (García de Jalón, Rodríguez, y Vidal, 2005).
El los ejemplos de la Tabla III, el for y parfor realizan el mismo cálculo y obtienen el mismo
resultado, la diferencia radica en que el segundo utiliza todos los procesadores disponibles de
forma concurrente, donde resultado de cada índice es arbitrario y no se garantiza una
secuencia, es decir, el valor A(500) puede ser calculado antes o después de A(120).
Tabla III: Instrucciones for y parfor
Ciclo Secuencial Ciclo Paralelo
for i=1:1024
A(i) = sin(i*2*pi/1024);
end
plot(A)
parfor i=1:1024
A(i) = sin(i*2*pi/1024);
end
plot(A)
35
Los valores del arreglo A estarán disponibles después de que todos los datos sean regresados y
el ciclo termine (véase Figura 14). La única restricción que se tiene para usar los ciclos en
paralelo es no tener iteraciones con variables dependientes de otras iteraciones (MathWorks,
2011c). La tabla IV muestra el código de un ciclo for que contiene código secuencial donde el
valor de la variable A no depende de la variable i. Aunque el valor de los elementos de A sea
igual, el valor de d no es el mismo.
Tabla IV: a) ciclo secuencial; b) Ciclo paralelo con variables dependientes
(a) Código Secuencial (b) Código paralelo
clear A
d = 0; i = 0;
for i = 1:4
d = i*2;
A(i) = d;
end
A
d
i
clear A
d = 0; i = 0;
parfor i = 1:4
d = i*2;
A(i) = d;
end
A
d
i
En el ejemplo de la tabla IV se está usando una variable A, donde los valores dependen de la
variable i, Aunque el valor de los elementos de A son iguales, el valor de d no es el mismo. En
el código secuencial, las iteraciones se ejecutan una tras otras, de modo que después d tiene el
valor que tenía en la última iteración del ciclo. En el código paralelo donde está el bucle
parfor, las iteraciones se ejecutan en paralelo, no en secuencia, de modo que sería imposible
asignar un valor a d después de finalizar este ciclo. Esto también se aplica a la variable i. Por
lo tanto, el comportamiento del bucle parfor se define de modo que no afecte a los valores de
d e i fuera del ciclo y sus valores seguirán siendo los mismos antes y después del ciclo. Así, un
código donde resida un parfor requiere que cada iteración de este ciclo sea independiente de
las otras iteraciones y que todo el código que sigue al ciclo parfor no dependa de la secuencia
de iteración del ciclo.
La caja de herramientas de Computación Paralela que se ofrece en MATLAB, mejora el
rendimiento de ejecución para cada ciclo, ya que permite la programación para que se ejecuten
36
iteraciones de ciclos de forma simultánea. Por ejemplo, un ciclo de 100 iteraciones podría
ejecutarse en un Cluster de 20 equipos con MATLAB, por lo que cada uno ejecutaría sólo 5
iteraciones del ciclo. No se reduciría en 20 veces la velocidad, debido a la sobrecarga de las
comunicaciones y el tráfico de red pero se obtendría un incremento en la velocidad de forma
significativa. Cuando se ejecutan los programas que contienen ciclos parfor en la máquina
local, se podría tener una mejora significativa en el desempeño, siempre y cuando el
procesador del equipo incluya más de un núcleo de procesamiento (Kepner, 2009).
Figura 14: Ejecución de código en forma paralela por el parfor
III.2 Principios para cambiar un código simple a paralelo.
Se puede modificar un simple ciclo “For”, de tal manera que se ejecute en paralelo. Con el
siguiente ejemplo que no contiene muchas instrucciones puede verse que no se requiere
mucho tiempo para su ejecución, sin embargo, se pueden aplicar los mismos principios para
ciclos con más instrucciones.
Ejemplo: Se considera el siguiente ciclo para generar los puntos de una onda Senoidal para
después graficarla (MathWorks, 2011a):
37
for i=1:1024
A(i) = sin(i*2*pi/1024);
end
plot(A)
Proceso a seguir:
Paso 1.- Para interactuar con el código que contiene un ciclo paralelo, primero debe abrirse el
administrador de trabajos paralelos conocido como MatLab pool, de esta forma se tiene acceso
a las sesiones de trabajo también conocidas como Workers o laboratorios, para la ejecución de
las iteraciones del ciclo. El MatLab pool prepara el entorno para utilizar todos los núcleos o
procesadores disponibles y se asignan a una sesión de trabajo.
matlabpool open
Paso 2.- Se reemplaza la sentencia for por un parfor, con esto se indica al administrador de
trabajos que el código entre la sentencia parfor-end deberá de ejecutarla en las diferentes
sesiones de trabajo disponibles habilitadas en el paso 1.
parfor i=1:1024
A(i) = sin(i*2*pi/1024);
end
plot(A)
La diferencia en este ciclo es la sentencia parfor en lugar del for, sin embargo, los resultados
obtenidos no difieren en ambos ciclos.
3.- Cuando ha terminado de ejecutarse el código, hay que cerrar el administrador de
laboratorios para liberar los recursos asignados a cada sesión de trabajo.
matlabpool close
38
En este ejemplo se trabajaron con todos los procesadores disponibles, sin embargo, puede
indicársele al MatLab la cantidad de sesiones de trabajo que se necesitan para su ejecución, ya
sean remotos o locales. Los segmentos de código secuencial “for-end” y “parfor-end” se
ilustran con la finalidad de resaltar que los resultados son los mismos utilizando el cómputo
paralelo, la diferencia radica que las sentencias que se encuentran entre el parfor-end se
ejecutan en varios procesadores y en diferente secuencia, viéndose reflejado la mejora en el
tiempo de cálculo con ciclos con más iteraciones.
39
Capítulo IV.- Procesamiento de imágenes
Los métodos y técnicas modernas de procesamiento de imágenes permiten la extracción de
información en su representación digital de las propiedades, fenómenos naturales y artificiales.
Por otra parte las facilidades de nuestra época que nos permiten adquirir, almacenar, transmitir
y compartir imágenes en formatos digitales, hacen que su uso sea cada vez mayor. Es por lo
anterior, que es importante abrir una brecha en el área de generación del conocimiento en los
conceptos y aplicaciones fundamentales del procesamiento digital de imágenes.
IV.1 ¿Qué es una imagen?
En Gonzalez y Woods (2002) se define una imagen como una función de dos dimensiones I(x,
y), donde (x, y) son espaciales y definen las coordenadas de un plano. La amplitud de I, para
cualquier par (x, y), es llamada intensidad o nivel de gris de la imagen en ese punto. Cuando (x,
y) y la intensidad tienden al infinito se toman valores discretos, y a esto se llama imagen o
imagen digital. A cada elemento identificado por el grupo (x, y) se le da el nombre de pixel y
corresponde a la unidad mínima que integra a la imagen. A cada pixel se le asocia un número
que representan el valor del brillo promedio, un número pequeño representa luminosidad baja
y un número elevado, una luminosidad alta (Gonzalez y Woods, 2002).
En la actualidad se ha logrado integrar más detalles en las imágenes, de tal forma que una
imagen puede contener más de un espectro. La Figura 15 muestra los 3 espectros que integran
una imagen a color en RGB. Para cada pixel se registran los niveles correspondientes a la
intensidad lumínica de cada color: rojo, verde y azul (que son los que definen el espectro RGB
por sus siglas en inglés).
40
IV.2 Procesamiento de imágenes
El procesamiento de imágenes corresponde a todas las operaciones que se pueden realizar
sobre una imagen digital, estos procesos nos permiten adquirir información específica sobre el
total o parte de la imagen, rotarla, crecerla o reducirla, cambiar contraste, modificar colores,
detectar bordes, detectar objetos, entre otras.
En esta tesis no se abordan todas las operaciones debido a que son muy extensas, sólo se
incluyen aquellas que nos permiten reconocer un objeto dentro de una imagen digital de
manera confiable, y que reciben el nombre de filtros gráficos.
IV.3 Ruido.
El ruido es considerado como señales parásitas o de interferencia, que deforman a la señal.
Una de las características de una imagen con ruido, es que un pixel con que ha sido afectado
por ruido tiene una intensidad muy diferente a la de los pixeles adyacentes (véase Figura 16 ).
68 18 35 70 74
71 76 65 77 11
9 57 15 5 86
13 94 77 71 41
47 48 76 32 69
Origen (0,0)
Pixel(x, y)
Espectros
(a) (b)
Figura 15: (a) Estructura de una imagen digital; (b) Imagen digital con tres espectros
41
Hay varios factores que pueden generar ruido en una imagen:
El medio que la rodea cuando se le adquiere
La calidad del sensor
La calidad de la muestra
Figura 16:(a) Ruido; (b) Imagen adquirida; (c) Imagen con ruido
IV.4 Filtros gráficos de reconocimiento basados en correlación
Existen varios tipos de filtros de correlación3 que permiten reconocer la posición de un objeto
en una imagen dado un objeto de referencia. Las operaciones que se requieren sobre las
imágenes son llevadas al dominio de la frecuencia debido a que el resultado de aplicar el filtro
es más rápido, y la función matemática que permite hacer este proceso es la transformada de
Fourier (Ramos Michel, 2008).
Para determinar cuantitativamente las capacidades de detección de los filtros de correlación se
utilizan diversos criterios como son: razón señal-ruido, capacidad de discriminación (DC),
razón pico-energía de salida, entre otros (B. V. K. Vijaya, et al., 2005). De estos criterios, los
que se utilizaron en el trabajo que aquí se presenta son la capacidad de discriminación y el
error de localización, mismos que a continuación se describen brevemente.
3 El término correlación se utiliza generalmente para indicar la correspondencia o la relación recíproca que se da entre dos o
más cosas, ideas, personas, entre otras.
42
IV.5 Capacidad de Discriminación (DC)
La DC (Yaroslavsky, 1993) es formalmente definida como la habilidad de un filtro para
distinguir un objetivo de otros objetos diferentes. Si un objetivo está incrustado en un fondo
que contiene objetos falsos, entonces la capacidad de discriminación puede expresarse como
sigue:
| |
| |
(1)
Donde CB es el máximo en el plano de correlación sobre el área del fondo a ser rechazada y,
CT es el máximo en el plano de correlación sobre el área de la posición del objetivo. El área de
posición del objetivo se determina en la vecindad cercana a la localización real del objetivo, en
tanto que el área del fondo es complementaria al área del objetivo. En las simulaciones por
computadora que se realizaron en este trabajo de investigación, el área de la posición del
objetivo se selecciona como el área del objetivo. Valores negativos de DC indican que el filtro
falla en reconocer al objetivo.
IV.6 Error de Localización.
La localización exacta del objetivo puede ser caracterizada por medio del error de localización
(LE) el cual se define como:
√ ̃ ̃
(2)
Donde ̃ ̃ son las coordenadas de la posición exacta del objetivo y las
coordenadas del pico de correlación que se toman como la estimación de la posición del
objetivo, respectivamente.
43
IV.6.1 Filtro Espacial de Correspondencia (MSF)
El filtro espacial de correspondencia MSF4 (VanderLugt, 1964) se diseña considerando que el
ruido de entrada se traslapa con el objetivo. Las limitaciones son: un pico de correlación
amplio y sensibilidad a distorsiones, presenta un funcionamiento inadecuado para las
imágenes que contienen objetivo espacialmente separado del fondo (Javidi y Horner, 1994).
En la ecuación (3) se tiene la función de transferencia H(u) del filtro lineal invariante, donde
N(u) representa la densidad espectral definida en el dominio de la frecuencia espacial y T*(u)
representa el conjugado de la transformada de Fourier del objetivo.
(3)
IV.6.2 Filtro Inverso (IF)
Este filtro se obtiene maximizando el criterio definido por la razón entre pico y energía de
correlación, de ahí que produzca picos muy definidos en su salida. Sin embargo, es poco
atractivo debido a su sensibilidad al ruido de entrada (Javidi y Horner, 1994).
En la Ecuación (4) se tiene la función de transferencia H(u) que corresponde al filtro inverso
(IF5). es el conjugado complejo de la transformada de Fourier de la escena. Debido a
que la mayoría de las imágenes tienen más energía en las frecuencias bajas que en las altas,
este filtro suprime las bajas frecuencias más que las altas (B. V. K. Vijaya, et al., 2005).
| |
(4)
4MSF - Matched Spatial Filter 5 IF - Inverse Filter
44
IV.6.3 Filtro de Sólo Fase (POF)
El filtro de sólo fase (POF6) maximiza la eficiencia de luz, por lo que es capaz de reconocer
objetos en escenas con diferentes grados de luminosidad (Horner y Gianino, 1984).
| |
(5)
En la Ecuación (5) H(u) es la función de transferencia del Filtro de solo fase; S(u) es la
transformada de Fourier de la escena, S*(u) es el conjugado de la escena.
IV.6.4 Filtro óptimo (OF)
El Filtro óptimo (OF7), minimiza la posibilidad de errores anómalos en la localización del
objeto. Una característica importante es su adaptabilidad a la escena debido a que considera la
energía de objetos no deseados. La desventaja de este filtro es la baja eficiencia de luz en la
implementación óptica (Yaroslavsky, 1993).
H(u) en la ecuación (6) es la función de transferencia del filtro óptimo, T(u) corresponde a la
transformada de Fourier del objetivo y T*(u) a sus respectivo conjugado. S(u) representa la
transformada de Fourier de la escena.
| | | |
(6)
6POF - Phase only filter 7OF - Optimum Filter
45
IV.6.5 Implementación de los filtros de correlación
Hasta el momento se han presentado las fórmulas y características principales de los filtros,
ahora falta aclarar la forma en que se aplican los filtros en una escena y así lograr la detección
y localización del objeto. Para esto se define un plano de correlación c(x) definido en (Ramos
Michel, 2008) como:
{ }
(7)
Donde S(u) es la transformada de Fourier de la escena y H(u) es la función de transferencia del
filtro a aplicar. La multiplicación entre S y H se realiza de elemento a elemento, también
conocido como producto punto. Una vez obtenido c(x), se busca el valor más alto obtenido en
el plano de correlación, pues es donde se supone que se ha determino la ubicación del objeto
en la escena. En la Figura 17(a) se tiene la imagen objetivo a localizar. La Figura 17(b) es la
escena que contiene la imagen objetivo que será localizada. Los planos de correlación
obtenidos al aplicar el filtro generalizado Óptimo en tres dimensiones y dos dimensiones, ver
figuras 18(a) y 18(b) respectivamente. En este caso, la localización del objetivo se realizó de
manera exacta.
Figura 17: (a) objeto a localizar; (b) escena que contiene el objeto
46
Figura 18: Plano de correlación obtenido entre el objetivo y la escena de la Figura 17(a): (a) en tres dimensiones; (b) en dos dimensiones
47
Capítulo V.- Desarrollo de la paralelización
La programación en paralelo permite hacer uso de todas las unidades de procesamiento
disponibles en la ejecución de una tarea, esto puede representar un mayor desempeño en el
proceso, con mejoras sobre todo en tiempo de procesamiento y obtención de resultados. Un
algoritmo que pueda explotar todo el poder computacional de los procesadores puede ser una
herramienta muy útil, sin embargo, un algoritmo que resulte óptimo para una aplicación,
puede no serlo para otra, esto es debido a que el programador de los algoritmos de ejecución
paralela, debe de considerar algunos factores importantes al momento de su programación.
La tarea de conversión de un algoritmo secuencial a un algoritmo de procesamiento en
paralelo no es fácil de escribir, debido a una larga lista de factores que se deben considerar
más allá de la simple corrección funcional básica del programa. Los factores a tener en
consideración son:
Rendimiento: Latencia y beneficio,
Eficiencia: Procesamiento, ancho de Banda y memoria,
Costo de Software: Tamaño del código y la portabilidad,
Costo de Hardware: El tamaño y poder del hardware.
V.1 Características de aplicaciones paralelas
Los algoritmos paralelos pueden tener diferentes características, y algunas impactan
directamente su diseño. Algunas características a considerar en el momento de realizar la
programación de un algoritmo para ejecución en paralelo son las siguientes (Kepner, 2009):
Estructura de datos: Los arreglos en cada etapa del programa consumen una cantidad
considerable de memoria, y es en donde muchos de los cálculos se realizan.
48
Complejidad Computacional: El total de operaciones realizadas y cómo dependen de
los parámetros de los algoritmos.
Operaciones por cada dato: El número de operaciones realizadas en cada elemento de
datos.
Grado de paralelismo: Es el número de procesadores a usar en los algoritmos y cómo
están relacionados con las estructuras de datos.
Complejidad de comunicación: Es el total de número de datos que fluyen al momento
de ejecutar el algoritmo paralelo.
Proporción entre los cálculos y la Comunicación: Es la cantidad de cálculos realizados
por el flujo de los elementos de datos.
V.2 Aceleración (SpeedUp)
La medición de rendimiento en ambientes paralelos da a conocer cuál es el beneficio obtenido
cuando se usa paralelismo y cuál es la aceleración que resulta por el uso de dicho paralelismo.
El SpeedUp (véase Ec. 8) para p procesadores Sp, es el cociente entre el tiempo de ejecución de
un programa secuencial Ts, y el tiempo de ejecución de la versión paralela del mismo
programa ejecutado en p procesadores Tp, quedando su fórmula como se muestra en la
ecuación (8) (Trujillo Rasúa, 2009).
(8)
Por ejemplo si Sp, es igual a 2, esto indica que al ejecutar el programa en varios procesadores
se ha reducido el tiempo a la mitad. En el caso ideal, el tiempo de ejecución de un programa
en paralelo con p procesadores será p veces inferior a la de su ejecución con un solo
procesador, teniendo todos los procesadores igual potencia de cálculo. Por tal motivo la mayor
49
velocidad (SpeedUp) que puede alcanzar Sp es p, pero esto generalmente no sucederá debido a
que existe tiempos extras necesarios para la sincronización del trabajo en todos los
procesadores (Figueria, 1996; Huerta Pellitero, 2009; Trujillo Rasúa, 2009).
V.3 Eficiencia.
La eficiencia muestra el grado de aprovechamiento de los procesadores que se utilizan para la
resolución del problema, comparado con el esfuerzo desperdiciado en comunicación y
sincronización entre ellos. El valor máximo que puede resultar es 1, que significa el 100% de
aprovechamiento. La eficiencia es el resultado del cociente entre el SpeedUp y el número de
procesadores. véase ecuación (9) (Trujillo Rasúa, 2009).
(9)
Los algoritmos con un Speedup lineal (Sp = p) y los algoritmos que corren en un solo
procesador tienen una eficiencia de 1, mientras que los demás algoritmos tiene eficiencia que
se aproxima a cero conforme se incrementa el número de procesadores.
Una vez definidas las características y la forma de evaluar el rendimiento de los algoritmos a
emplear, se procedió a analizar el algoritmo correspondiente al reconocimiento de objetos en
las imágenes a partir de los filtros de correlación que inicialmente se programaron bajo el
esquema secuencial y que se modificaron para que se ejecutaran en el ambiente paralelo de
MatLab.
V.4 Herramientas de Hardware
En este trabajo se utilizó un servidor para llevar a cabo el procesamiento en paralelo, y dos
equipos personales de desarrollo con características generales para la evaluación y
50
comparación de resultados. A continuación se desglosan las características técnicas de cada
uno:
V.4.1 Servidor DELL
El servidor DELL cuenta con: dos procesadores Xeon de seis núcleos corriendo a una
velocidad de reloj de 2.3 GHz, un bus frontal de 1066 MHz, memoria de 24 GB ECC y un
disco duro de 500 GB. El sistema operativo que ejecuta es Windows 7 a 32 bits.
V.4.2 Equipo Personal
Se utilizaron dos equipos personales con las siguientes características:
Equipo Personal 1, Computadora Intel Core 2 Duo (6420) con dos núcleos corriendo a
2.13 GHz, con bus frontal de 1066 MHZ, memoria DDR 3 de 2 GB y un disco duro de
500GB. El sistema operativo que ejecuta es Windows 7 a 32 bits.
Equipo Personal 2, Portátil MacBook Pro, con procesador Intel Core 2 Duo a 2.2 GHz,
con una velocidad de bus de 800 MHz, memoria DDR2 de 4 GB y Disco Duro de 320
GB. El sistema operativo es OSX 10.7 a 64 Bits,
V.5 Herramientas de Software.
Las herramientas de software se componen del lenguaje de programación, las librerías
secuenciales y paralelas. En el desarrollo del ambiente paralelo propuesto en este documento,
se empleó el lenguaje M y las librerías de computación paralela (Parallel Computing ToolBox)
que están integradas en el IDE de MatLab.
51
V.6 Algoritmo Secuencial.
En la Figura 19 se observan los estados del algoritmo secuencial durante el proceso de
reconocimiento del objeto
El proceso se describe a continuación:
1. El algoritmo requiere una imagen de entrada identificada como Escena (I). Se carga en
una matriz de 256 x 256 x 3 elementos, cada una de las matrices de 256 x 256
corresponde a un espectro RGB, del cual sólo tomaremos el primero para realizar las
operaciones, y que representa una imagen en escala de grises.
2. De la misma forma, carga la imagen que contiene el objeto Target (T) a localizar en
una matriz 256 x 256 x 3 (RGB), tomando la primera matriz para los cálculos.
3. El Target es combinado con la escena en coordenadas conocidas (Tc) para proceder a
realizar el reconocimiento. Es importante conocer las coordenadas del Target en la
escena, pues a partir de ellas y de la ubicación obtenida por el filtro, se determina el
error de localización.
4. A la escena (I) combinada con el Target (T) se agrega ruido (R), con la finalidad de
evaluar la inmunidad del filtro a las distorsiones, degradaciones o ruido aditivo.
5. Las matrices resultantes para cada filtro (If), definen el plano de correlación, sobre el
cual, se realiza un proceso de búsqueda (L) del valor más alto dentro de la región del
objetivo y fuera de éste, con el propósito de localizar al objeto y obtener el valor de la
capacidad de discriminación del filtro en cuestión.
I
T
R
Ic +
+ I
Tc
I c LE + +
Figura 19: Diagrama de estados de la aplicación de los filtros de correlación
52
6. Para cada filtro de correlación, se hace el cálculo del error de localización (LE) y de la
capacidad de discriminación, esto es con el objeto de determinar qué filtros tienen un
mejor desempeño para llevar a cabo el reconocimiento del objeto en la imagen.
Para los experimentos realizados, se utilizaron 30 imágenes de escena donde la ubicación del
objetivo variaba. Los tiempos requeridos para llevar a cabo las simulaciones de las 30
imágenes de escena diferentes en las que debe reconocerse el objetivo por parte de cada uno
de los cuatro filtros de correlación (MSF, IF, POF, OF) se grafican en la Figura 20. En dicha
figura se observa el crecimiento constante y lineal del tiempo necesario para el cálculo de los
filtros para cada una de las imágenes mediante el algoritmo original que se ejecuta de manera
secuencial.
Figura 20: Tiempos requeridos por el programa secuencial para procesar 30 imágenes
53
En la secciones posteriores se presenta cómo se pasó el programa secuencial de simulación
para el reconocimiento de objetos a un programa en ambiente en paralelo y la configuración
del entorno de ejecución.
V.7 Configuración del Entorno
La herramienta de paralelización de MatLab permite distribuir el trabajo entre diferentes
sesiones Workers o laboratorios mediante MatLab Distributed Computing Server (MDCS)
optimizando el procesamiento de la información. Para crear un Cluster con MatLab, es
importante seguir una serie de pasos para habilitar estas características y tener instalado:
MatLab Parallel Computing Toolbox, MatLab Distributed Computing Server, Administrador
de trabajos ( Scheduler).
V.7.1 MatLab Parallel Computing Toolbox
Parallel Computing Toolbox, proporciona las herramientas y el lenguaje necesario para la
programación de aplicaciones paralelas, así como los mecanismos de envío de trabajos para su
ejecución.
Parallel Computing Toolbox se instaló en el cliente del Cluster, debido a que es necesario
para poder iniciar el trabajo.
V.7.2 MatLab Distributed Computing Server,
El Distributed Computing Server (MDCS) se instala en todos las máquinas que forman parte
del Cluster, esta herramienta permite que los ejecutables generados por Parallel Computing
Toolbox se procesen en coordinación mediante un administrador de trabajos. Con MatLab
2008b se pueden crear hasta 4 Workers localmente (véase Figura 21).
54
Figura 21: Diagrama de bloques de Workers Locales
V.7.3 Administrador de trabajos (Scheduler)
El Administrador de trabajos (Scheduler) es el encargado de la iteración de los diferentes
componentes del Cluster. MatLab identifica a los administradores de trabajo en tres rubros
(MathWorks, 2011b):
Administrador Local: En conjunto de Parallel Computing Toolbox, la creación y prueba de los
trabajos en forma paralela sin hacer uso de recursos externos al equipo. El Administrador local no
puede interactuar con otros planificadores.
MathWorks Job Manager: Permite administrar los trabajos que serán procesados en el
Cluster, su función es la de localizar los trabajadores disponibles y distribuir el proceso entre
los diferentes nodos o máquinas. Los datos de este administrador no se eliminan ni las tareas
se detienen, de tal manera que se pueden obtener los resultados en una sesión posterior. Este
55
administrador provee mecanismos para compartir datos y acceder a los archivos necesarios
para evaluar las tareas en las diferentes máquinas mediante una ruta de acceso común entre
los nodos.
Administrador de Terceros: MatLab permite hacer uso de planificadores previamente
configurados en la red que interconecta las máquinas que forman el Cluster. Los
administradores compatibles son: LSF (Load Sharing Facility), Microsoft Windows HPC
Server, PBS Pro y TORQUE. MatLab puede integrar otros planificadores mediante un API
genérico.
La implementación del Cluster para nuestro propósito usa el administrador de trabajos de
MatLab (MathWorks Job Manager) (véase Figura 22)
Figura 22: Configuración del planificador de trabajos del Cluster
56
V.7.4 Implementación del Cluster.
Una vez instalado MatLab y sus librerías necesitamos registrar y ejecutar el MDCE (MatLab
Distributed Computing Engine). Para este paso y lo sucesivo se trabaja en una interfaz de
comandos MS-DOS desplazándonos a la ruta C:\Program
Files\MATLAB\R2008a\toolbox\distcomp\bin. Ver Figura 23.
Figura 23: Ruta de trabajo para inicializar el Cluster
Una vez ahí, se ejecuta el comando mdce install; y lo iniciamos con el comando mdce start
(véase Figura 24)
Figura 24: Instalación e inicialización del MDCE
Podemos revisar el estado de nuestros MDCE, Administradores de Trabajos y Workers con el
comando nodestatus (Figura 25).
57
Figura 25: Resultado de nodestatus
Teniendo inicializado el MatLab Distributed Computing Engine, procedemos a crear el
administrador de trabajos y Workers en nuestro equipo.
V.7.4.1 Creación del Administrador de Trabajos (Scheduler)
Como primer paso es necesario definir el Administrador de trabajos mediante las librerías de
MDCS. El directorio de instalación de las librerías en nuestra configuración de Windows 7
está localizado en la ruta:
C:\Program Files\MATLAB\R2008a\toolbox\distcomp\bin
La Figura 26, muestra la creación del administrador de trabajos de forma local usando el
archivo de procesamiento por lotes startjobmanager.bat.
startjobmanager.bat -name jmCluster –v
58
Donde el parámetro -name jmCluster, nombra al administrador de trabajos en su creación; –v
es el parámetro que nos permite visualizar el estatus de la tarea durante el proceso de creación.
Figura 26: Inicialización del Administrador de Trabajos jbCluster
V.7.4.2 Creación de las sesiones de trabajo.
De la misma forma se procede a crear los las sesiones de trabajo en el equipo local (véase
Figura 27). Asignamos un sesión de trabajo a cada núcleo de nuestro equipo, que en total
suman 24, y que para efecto de nuestro trabajo se configuran 10 núcleos, por tal motivo se
ejecuta el comando 10 veces asignando el nombre de cada sesión de trabajo.
startworker.bat -jobmanagerhost Martin-Pc -jobmanager jmCluster -name nodo1 startworker.bat -jobmanagerhost Martin-Pc -jobmanager jmCluster -name nodo2
.
.
. startworker.bat -jobmanagerhost Martin-Pc -jobmanager jmCluster -name nodo10
59
Figura 27: Creación de un Worker y la asignación al administrador de trabajos jmCluster
El parámetro -jobmanagerhost Martin-Pc le dice al Worker dónde se localiza el
administrador de trabajos, dónde se subordina; -jobmanager jmCluster proporciona el
nombre del planificador que previamente se registró y -name nodo1 asigna el nombre al
Worker que se va a inicializar, se puede verificar que todos los worker se asignaron sin
problemas mediante el comando nodestatus –infolevel 2 (Figura 28).
Figura 28: Información retornada por el comando nodestatus
60
V.8 Configuración de MatLab
Una vez creado el planificador y haber ligado los Workers a este, es necesario configurar el
MatLab para que pueda hacer uso del nuevo planificador (véase Figura 29), en el campo
“Configuration Name” escribimos el nombre con el cual MatLab lo reconocerá en su entorno
de ejecución.
Una vez configurado, guardamos los cambios y hacemos uso del nuevo administrador de
trabajos desde la ventana de comandos de MatLab con el comando matlabpool open jmNuevo
(véase Figura 30 ).
Figura 29: Configuración interna del MatLab del nuevo planificador
Figura 30: Uso del nuevo Administrador de trabajos desde MatLab
V.9 Algoritmo Paralelo.
61
El algoritmo paralelo es el producto de identificar en el algoritmo original las sentencias que
se ejecutan estrictamente en forma secuencial y las sentencias que pueden ser ejecutadas en
forma paralela. Dado a que se opto por usar el parfor-end las sentencias factibles de
paralelizar son las correspondientes a los ciclos for del algoritmo secuencial. Por lo tanto se
procedió a ubicar los ciclos for dentro del algoritmo y optimizar el código eliminando ciclos e
instrucciones innecesarias, posteriormente se procedió a solucionar problemas ocasionados por
el uso de variables dependientes dentro del ciclo principal. Una de las acciones referentes a la
optimización de código, fue la extracción de instrucciones que solo se ejecutaba una vez
dentro del ciclo principal, lo cual nos permitió también evitar dependencia de variables.
El algoritmo secuencial original presenta segmentos de código que se incluyen dentro de
cuerpo principal del ciclo, y que se ejecutan en un espacio de nombres distinto definido por las
funciones creadas por el programador. Las variables que se generan dentro del cuerpo del
parfor-end pertenecen a un espacio de nombres, cuando se accede a variables con espacio de
nombres distinto MatLab no permite paralelizarlo provocando un error de ejecución al
momento de compilar. La solución de este caso fue la inclusión del código de las funciones
dentro del ciclo parfor-end que permite homologar el espacio de nombres de todas las
variables.
Los ciclos presentes en el algoritmo secuencial representan en primera instancia el posible
código paralelo. La sentencia parfor de MatLab resuelve muchos de los problemas para la
ejecución paralela, más sin embargo, es importante tomar en cuenta que no sólo con utilizar
esta sentencia nos lleva a la solución. Los problemas más frecuentes son los relacionados a las
variables dependientes, que condicionan su valor a ciclos anteriores, y que de alguna forma
complican la programación en paralelo. La Figura 31 es la representación gráfica de una
ejecución del ciclo paralelo parfor y como el administrador de trabajos (job Manager)
administra la paralelización del algoritmo en diferentes bifurcaciones de ejecución dentro del
entorno paralelo previamente configurado.
62
A pesar de las grandes ventajas que provee la programación paralela, existen algunas
desventajas que pueden dificultar el desarrollo de las aplicaciones, por ejemplo, no es posible
realizar el seguimiento de errores en el código (debug) cuando se utiliza el paralelismo, debido
a que las intrucciones y variables se dividen en diferentes sesiones de trabajo, dificultando la
localización y corrección de los errores. Otro ejemplo es el acceso a los archivos para escritura,
ya que los archivos son abiertos de forma exclusiva provocando un error cuando una sesion de
trabajo intenta escribir en un archivo que se encuentra actualmente en uso.
MatLab proporciona herramientas que permiten explotar el poder computacional y que
facilitan la programación en paralelo. La infraestructura computacional con la que se cuenta
determina la configuración del entorno paralelo, las sesiones de trabajo que se pueden activar
y cual estará asignada a cada nodo o procesador disponible. El administrador de trabajos que
se encarga de administrar las tareas es definido de acuerdo a esta infraestructura y a las
necesidades del algoritmo que hace uso de este entorno paralelo.
Figura 31: Representación de una ejecución paralela
Archivo Principal Filtrop.m
Utilización del MDCE
Filtrop.m
Job Manager jmCluster
Ejecución Filtrop.m
Ejecución Filtrop.m
Ejecución Filtrop.m
Ubicación del jobmanager Creación del trabajo y tareas
Colocación del trabajo en cola de ejecución
Distribución de tareas
Recopilación de resultados Sesiones de trabajo Sesiones de trabajo
63
Capítulo VI.- Análisis experimental
En este capítulo se presentan los resultados obtenidos de la simulación de los filtros
mencionados para detección de objetos en un ambiente secuencial y en un ambiente paralelo.
VI.1 Características del Experimento
Para los experimentos llevados a cabo se utilizaron 30 imágenes de escena, donde la
localización del objetivo varía y en las cuales se aplicaron los fitlros de correlación MSF, IF,
POF, IOF. Dado que la finalidad es observar el comportamiento y resultado del algoritmo en
el ambiente paralelo, evaluando los parámetros de aceleración y eficiencia obtenidos en las
simulaciones que se realizan, se ejecuta el experimento con el algoritmo secuencial y con el
algoritmo paralelo. Al final se realiza el cotejo de los resultados de ambos algoritmos para
determinar la mejora obtenida. Cabe mencionar que el resultado de los filtros aplicados en
cuanto a los parámetros evaluados (error de localización y capacidad de discriminación)
concuerdan exactamente en los dos algoritmos.
En una primera etapa, se ejecutó treinta veces el programa secuencial y el paralelo con un
procesador, desde una a treinta imágenes, es decir en la primera ejecución se utilizó una
imagen y la última treinta imágenes. Se almacenaron los tiempos de cada ejecución en los dos
ambientes. Posteriormente se ejecutó solamente el algoritmo paralelo variando la cantidad de
procesadores y la cantidad de imágenes en cada uno (Ver Tabla V y Tabla VI).
VI.2 Análisis de Resultados
La Tabla V y la Tabla VI muestran los tiempos de ejecución del algoritmo original y los
tiempos obtenidos de la ejecución paralela y diferente cantidad de núcleos. Se puede observar
que a la tarea realizada por un núcleo en ambiente paralelo le tomó más tiempo en terminarla.
Lo anterior es debido a los mensajes de sincronización y notificación enviados para el control
en el ambiente paralelo necesarios para procesar la tarea.
64
Tabla V: Tiempos de procesamiento del algoritmo de filtros de correlación de uno a cinco núcleos
Imágenes Secuencial
Tiempo de procesamiento en ambiente paralelo expresado en segundos
1 núcleo 2 núcleos 3 núcleos 4 núcleos 5 núcleos
1 32.71321234 31.80172769 29.02996745 34.65520839 30.17839431 28.74771057
2 41.26103858 46.82326264 28.76613177 29.12093999 29.48953938 29.10620261
3 50.79098967 64.84032398 42.30127132 34.46899027 29.55002454 29.43657974
4 62.74135817 66.75249039 42.46361241 50.6984569 29.76261416 29.88564169
5 76.09171166 81.54428039 53.53715674 59.72513603 40.4680742 29.96750735
6 88.92843397 95.94013785 57.18736144 60.93491936 41.23119535 41.73830723
7 102.3725047 107.4936988 67.5088165 58.43276764 40.89199117 41.38812332
8 111.6989912 123.282393 69.29145951 72.91762435 41.82930483 42.58553525
9 124.6993381 133.1960854 78.28798488 70.70999294 52.30612177 41.44530901
10 135.9086768 135.7804511 81.745227 75.73837051 52.53333667 42.10562749
11 145.4892525 145.6099677 92.67828047 88.24410658 52.83274172 53.94956413
12 158.5378658 166.2004077 94.2466781 93.97197967 53.15061853 54.55898787
13 168.8290466 164.6559937 109.5505502 88.2918845 64.53736178 55.02347774
14 171.6294682 177.6745233 112.6738065 90.56400911 63.86374074 54.63628448
15 182.3922419 188.8171164 112.728777 96.52073134 65.0710834 55.14109701
16 193.297324 209.9252846 119.3770996 124.4857483 65.43976949 65.17669357
17 204.8934986 239.5339851 124.7236693 110.0971396 75.73055459 65.98981405
18 216.213544 239.8519436 128.6627524 123.975815 76.63658936 66.8111495
19 227.4003153 269.9575029 135.8927514 129.7140562 76.34828839 65.13372509
20 238.0326995 262.7040884 142.0442205 139.8447533 76.37458632 66.26454915
21 250.3050066 253.2316401 145.6730227 151.4405288 87.36116326 79.39417676
22 261.1185402 267.3791222 150.5720328 131.809197 87.58176383 77.99829079
23 272.3265842 277.235743 162.2005247 135.0412175 88.24392394 79.43038039
24 283.3647386 289.2842785 164.1023019 135.0942501 89.28619526 80.16944714
25 294.8000516 299.0670659 178.4343791 131.0241423 100.0273623 80.18619815
26 305.456958 310.8114872 173.9190021 144.5283558 100.554092 90.58834467
27 316.4590738 339.9623954 213.4498375 142.2636979 100.5255178 89.17867109
28 327.3155402 428.7688142 211.1228313 138.9151437 100.3331677 91.40903878
29 338.601243 409.5913123 209.0587169 144.0431484 111.0866591 92.26269135
30 348.8548843 418.1939704 242.2943633 151.4943151 110.9570577 90.87797913
Tabla VI: Tiempos de procesamiento del algoritmo de filtros de correlación de seis a diez núcleos
Imágenes Secuencial
Tiempo de procesamiento en ambiente paralelo expresado en segundos
6 núcleos 7 núcleos 8 núcleos 9 núcleos 10 núcleos
1 32.71321234 28.70959697 28.67148337 28.72748225 28.82639994 28.85767613
2 41.26103858 29.22131852 29.33643442 28.9824864 29.27438633 29.00751666
3 50.79098967 29.30753091 29.17848208 29.09454728 29.80922664 29.47613211
4 62.74135817 30.13214812 30.37865454 29.47627685 29.49331927 29.86653091
5 76.09171166 29.74404231 29.52057728 30.34105659 30.47290579 32.29917677
6 88.92843397 37.06740225 32.39649728 32.93843196 32.65098443 35.95739762
7 102.3725047 37.12088717 32.85365103 53.63305469 33.47547614 37.31786411
8 111.6989912 43.81449843 45.04346161 49.79402663 43.07135518 40.63984455
9 124.6993381 43.91331411 46.38131921 59.7178541 45.04131624 48.68758726
10 135.9086768 43.19791796 44.29020843 60.56404659 55.29337239 57.2754184
11 145.4892525 52.16998993 50.39041573 69.72017577 61.1370003 72.1490891
12 158.5378658 52.16042915 49.76187043 59.70793453 66.27101527 67.2080044
13 168.8290466 50.42021022 45.81694271 65.99720945 67.55663194 74.57719324
14 171.6294682 59.4566252 64.27696593 60.6926071 68.42343154 69.72777212
15 182.3922419 59.93141092 64.72172484 61.97138309 84.67735358 61.01239637
16 193.297324 67.84514291 70.51359224 70.54373704 60.26623141 63.82293726
17 204.8934986 64.77828864 63.56676323 77.06643467 82.55536081 80.45564395
18 216.213544 61.90954269 57.00793588 83.22938721 78.26312365 67.68331078
19 227.4003153 68.0301652 70.92660532 77.81197793 84.45926908 63.4309278
20 238.0326995 64.03057749 61.79660584 82.65545185 89.81025409 92.70079628
21 250.3050066 80.20662626 81.01907576 67.07056679 110.4444706 86.1699345
22 261.1185402 80.72339247 83.44849415 78.64007745 81.24797599 100.8255261
23 272.3265842 77.03232346 74.63426653 83.84051438 107.285599 118.7602478
24 283.3647386 80.92495693 81.68046672 68.18322551 107.6375787 104.1508599
25 294.8000516 83.71825022 87.25030229 84.7716133 118.1116528 108.169374
26 305.456958 82.95435338 75.32036209 80.66905622 101.7961258 96.98117215
27 316.4590738 82.86254737 76.54642366 87.54749653 121.3206574 99.3959441
28 327.3155402 100.310553 109.2120672 90.18180618 96.6927326 109.932223
29 338.601243 86.73739103 81.21209072 91.88894154 111.7424394 126.1473433
30 348.8548843 94.72365616 98.5693332 96.74874841 130.2090946 109.8078974
65
En la Figura 32 se muestra la comparativa de los tiempos del programa secuencial vs los
tiempos del programa paralelo listados en la Tabla V, tomando los valores de los primeros
cuatro procesadores y comparándolas con los tiempos del algoritmo secuencial, esto se hace
para efecto de mostrar de la tendencia sobre la reducción de tiempo. El total de la muestra
comprende 10 núcleos. El tiempo que tarda el programa secuencial en procesar la tarea, se
incrementa proporcionalmente respecto a la cantidad de imágenes. La Figura 32(a), muestra
claramente que es más eficiente el programa secuencial vs un procesador como se menciona
anteriormente. Conforme se incrementan los procesadores, se observa en las Figura 32(b),
Figura 32(c) y Figura 32(d) que los tiempos en procesar el total de las 30 imágenes se reducen
en un 35.8%, 41.68% y 59.80% respectivamente.
Figura 32: Comparativo de los tiempos de procesamiento secuencial vs Paralelo
Idealmente es de esperar que al incrementar la cantidad de procesadores asignados a una tarea,
ésta reduzca sus tiempos de manera proporcional, sin embargo, el asignar más procesadores,
66
incrementa la cantidad de mensajes de control, de tal forma que el tiempo que generan los
mensajes puede ser mayor al generado por la tarea misma.
Figura 33: Comparativo general de los tiempos de procesamiento hasta 4 procesadores
Comparando los tiempos de los diez procesadores usados en un sola grafica general (véase
Figura 33), se pone de manifiesto que el incremento de procesadores no garantiza la reducción
de tiempo en el mismo porcentaje. La Figura 34 y Figura 35Figura 35 demuestra que la
asignación de 5, 6 y 7 procesadores proporciona el mejor ahorro de tiempo en la ejecución del
algoritmo paralelo para el reconocimiento de objetos.
Tie
mp
o e
n S
egu
nd
os
Imágenes
Gráfico comparativo general de los tiempo de procesamiento
Secuencial
1 procesador
2 procesadores
3 procesadores
4 procesadores
5 procesadores
6 procesadores
7 procesadores
8 procesadores
9 procesadores
10 procesadores
67
Figura 34: Promedio en horro de tiempo con procesamiento paralelo
Figura 35: Porcentaje promedio de ahorro en tiempo
Tie
mp
o e
n S
egu
nd
os
Procesadores Asignados
Tiempo Secuencial
Ahorro
1 2 3 4 5 6 7 8 9 10
Ahorro -8.23% 35.80% 41.68% 59.80% 63.40% 63.64% 63.87% 60.63% 58.45% 58.76%
Porcentaje de ahorro en tiempo
68
La Figura 36 se grafica el Speedup “ideal” del algoritmo paralelo alcanzado con los diez
procesadores y que nos sirve de referencia. La serie “Real” es el Speedup obtenido en la
evaluación del algoritmo paralelo de los filtros correlacionados, claramente se logra observar
que la gráfica comienza a estabilizase en un aproximado de 2.5 de Speedup. Demostrando que
el algoritmo paralelo presenta una estabilidad de la aceleración (SpeedUp) a medida que se
anexan más procesadores a la tarea, no beneficiando en gran medida al ahorro de tiempo en
procesamiento.
Figura 36: SpeedUp real vs ideal
En la sección V.3 se presenta la definición de eficiencia como la métrica para evaluar el uso de
los recursos de cómputo en la ejecución del algoritmo paralelo. Los valores graficados
corresponden a los diez procesadores configurados y se presentan en la Figura 37, donde se
muestra que la eficiencia del uso de los recursos computacionales decrece a medida que se
incluyen procesadores a la ejecución del algoritmo paralelo, la información que nos
proporciona la ecuación (9) de eficiencia en conjunto con el resultado de la aceleración de la
Spe
ed
Up
máx
imo
ide
al
Número de Procesadores
gráfico SpeedUp Ideal vs Real
Ideal
Real
69
ecuación (8), deja ver claramente que a mayor cantidad de procesadores los beneficios se
reducen y los costos por uso de poder computacional se incrementan.
Figura 37: Medición de la eficiencia del algoritmo paralelo hasta con 10 procesadores
Eficiencia, 1, 0.929187256
Eficiencia, 2, 0.78640977
Eficiencia, 3, 0.595983152
Eficiencia, 4, 0.663371582
Eficiencia, 5, 0.593621724
Eficiencia, 6, 0.49929002
Eficiencia, 7, 0.431910231
Eficiencia, 8, 0.346891591
Eficiencia, 9, 0.281677379 Eficiencia, 10, 0.256843937 P
orc
en
taje
de
ap
rove
cham
ien
to
Número de procesadores
Título del gráfico
70
Conclusiones
En este trabajo se muestra que la programación paralela no es una tarea sencilla, incluso
personas capacitadas pueden tener problemas. Esto debido a la dificultad de identificar el
código secuencial que puede programarse en paralelo, y a las variables dependientes que
pueden limitar la ejecución en múltiples procesadores. La gran diversidad de problemas
requiere algoritmos paralelos específicos para el problema y arquitectura donde se ejecuta. La
asignación total de los recursos que se disponen en donde se ejecuta el algoritmo paralelo, no
garantiza que el algoritmo se desempeñe de forma eficiente, en ocasiones repercute de forma
negativa en su desempeño, incluso, puede generar costos monetarios por usar unidades de
procesamiento que no necesita.
El algoritmo de filtros de correlación, permite detectar un objeto en particular dentro de una
imagen, sin embargo, es necesario que ofrezca confiabilidad en la detección y localización. Al
aplicar la programación en paralelo al algoritmo se lograron reducir los tiempos necesarios
para completar estas tareas hasta en un 63.87% asignado recursos de forma óptima, de esta
forma los tiempos de espera de resultados se reducen considerablemente. Se observó que el
asignar más de 7 procesadores al algoritmo paralelo decreció el ahorro en tiempo y con claras
tendencias a ser menos eficiente, además de usar más energía y unidades de procesamiento. El
cálculo de la eficiencia mediante la ecuación (9) confirma claramente que el uso de los
recursos disminuye conforme se incrementan los procesadores asignados.
Los resultados de las simulaciones por computadora que se realizaron y que se presentan en
este trabajo, muestran el desempeño alcanzado por los filtros ejecutados en un ambiente
paralelo con respecto a la programación secuencial tradicional. Sobre los resultados obtenidos,
es importante señalar que dada la cantidad de experimentos realizados en cada simulación, la
información que se obtiene es lo suficientemente confiable para hacer las conclusiones
presentes.
71
Cabe señalar que los resultados obtenidos con la programación secuencial fueron los mismos
a los obtenidos en ambiente paralelo, con la diferencia de ahorro en tiempo. Esto beneficia en
gran medida a quienes requieren llevar a cabo tareas de reconocimiento de objetos. De tal
manera la programación paralela muestra ser una solución viable sin la necesidad de mucha
inversión en infraestructura, pudiendo integrar equipos de económicos de bajo poder
computacional al ambiente paralelo y distribuir pequeños procesos para su solución en cada
equipo integrado, obteniendo ahorros en tiempo y un incremento en el poder de procesamiento
de manera significativa.
72
Bibliografía
Avila George, H. (2010). Verificación de Covering Arrays utilizando Supercomputación y
Computación Grid. Master, UNIVERSIDAD POLITÉCNICA DE VALENCIA.
B. V. K. Vijaya, K., Abhijit, M., y Richard, J. (2005). Correlation Pattern Recognition:
Cambridge University Press.
Bell, C. G. (1985). Multis: A new Class of multiprocessors computers. Science 228, 463.
Cabrillo Bartolome, I. (2008). Operación y desarrollo de Herramientas para la gestión de
datos en un entorno de GRID. Universidad de Cantabria.
Dandamudi, S. (2003). Hierarchical Scheduling in Parallel and Cluster System: Kluwer
Academic / Plenum Publishers.
Deitel, H. M. (1985). Introducción a los sistemas operativos: Addison Wesley Iberoamericana.
Figueria, C. (1996). Arquitecturas Paralelas. 63.
Fruehe, J. (2005, Mayo 2005). Planning Considerations for Multicore Processor Technology.
Dell Power Solutions, 120.
García de Jalón, J., Rodríguez, J. I., y Vidal, J. (2005). Aprenda Matlab 7.0 como si estuviera
en primero E. T. S. d. I. Industriales (Ed.) (pp. 136).
Gonzalez, R. C., y Woods, R. E. (2002). Digital Image Processing: Prentice Hall.
Greenberg, A. D., y Greenberg, s. (1995). Digital images a practical guide: McGraw-Hill.
Hennessy, J. L., y Patterson, D. A. (1993). Arquitectura de Computadores. Un enfoque
cuantitativo: McGraw-Hill/Interamericana de España, S.A.
Hernández Barragán, E., y Jorba Esteve, J. (2010). Análisis de rendimiento de aplicaciones en
sistema multicore
6to Congreso Colombiano de Computación, 6.
Horner, J. L., y Gianino, P. D. (1984). Phase-only matched filtering: Appl. Opt.
73
Bibliografía (continuación)
Huerta Pellitero, P. (2009). Sistemas de multiprocesamiento simétrico sobre FPGA. Dr.,
Universidad Rey Juan Carlos, Mayo de 2009.
Intel Corporation (2011). Tecnología Hyper-Threading, 2011, from
http://www.intel.com/cd/corporate/techtrends/emea/spa/platform-technology/hyper-
threading/310512.htm
JáJá, J. (1992). An introduction to Parallel Algorithms: Addison Wesley.
Javidi, B., y Horner, J. L. (1994). Real-time optical information processing: Academic Press.
Kepner, J. (2009). Parallel MATLAB for Multicore and Multinode Computers J. J. Dongarra
(Ed.) (pp. 252).
MathWorks. (2011a). Introduction to Parallel Solutions Retrieved 13 Nov 2011, 2011, from
http://www.mathworks.es/help/toolbox/distcomp/brjw1e5-1.html
MathWorks. (2011b). MATLAB Distributed Computing Server 5.0 Retrieved 13 Nov 2011,
2011, from http://www.mathworks.com/products/datasheets/pdf/matlab-distributed-
computing-server.pdf
MathWorks. (2011c). Product Overview Retrieved 13 Nov 2011, 2011, from
http://www.mathworks.es/help/techdoc/learn_matlab/f0-14059.html
MPI-Forum. (2009). MPI: A Message-Passing Interface Standard Introduction to MPI (pp.
647).
Ortega Lopera, J. (2009). Entre la profecía de Moore y la ley de Amdahl.
Pérez, J. A. d. B. (2007). utilizacion y administracion avanzadas de sistemas GNU/Linux y
aplicaciones software libre para estudiantes universitarios clustering y Alta
disponibilidad en GNU/Linux
Plaza Nieto, E. J. (2003). [Cluster Heterogéneo De Computadoras].
Quinn, M. J. (2004). Parallel Programming in C with MPI and OpenMP. Boston: McGraw
Hill.
74
Ramos Michel, E. M. (2008). Reconocimiento confiable de objetos degradados. Doctor en
Ciencias, CICESE, Ensenada.
Sánchez Enriquez, H. Y. (2007). Clustering y Grid Computing. 16. Retrieved from
Tanenbaum, A. S. (2003). Sistemas Operativos Modernos: Prentice Hall.
Tanenbaum, A. S., y Goodman, J. R. (2000). Organización de Computadoras un enfoque
estructurado (R. C. Chávez, Trans.). Mexico: Prentice Hall.
Tian, T., y Shih, C.-P. (2009). Software Techniques for Shared-Cache Multi-Core Systems
Retrieved 9 Nov 2011, 2011, from http://software.intel.com/en-us/articles/software-
techniques-for-shared-cache-multi-core-systems/
Top500.org. (2011). TOP500 Statistics, 2011, from
http://www.top500.org/charts/list/38/procfam
Trujillo Rasúa, R. A. (2009). Algoritmos paralelos para la solución de problemas de
optimización discretos aplicados a la decodificación de señales. Dr. Doctoral,
Universidad Politécnica de Valencia.
Universidad de Talca, F. d. I. (2007). Computación paralela y distribuida PVM: Parallel
Virtual Machine (pp. 4).
VanderLugt, A. B. (1964). Signal detection by complex filtering. IEEE Trans. Inf. Theory.
Yaroslavsky, L. P. (1993). The theory of optimal methods for localization of objects in
pictures. E. Wolf (ed.). Progress in Optics XXXII . Elsevier Science, Amsterdam, 145-
200.
