0

UNIVERSIDAD NACIONAL AUTÓNOMA DE MÉXICO

POSGRADO EN CIENCIA E INGENIERÍA DE LA COMPUTACIÓN

“ESTUDIO DE SISTEMAS MULTICORE

PARA CÓMPUTO DE ALTO RENDIMIENTO”

T E S I S

QUE PARA OBTENER EL GRADO DE:

MAESTRA EN CIENCIAS

(COMPUTACIÓN)

P R E S E N T A:

CLARA VICENTE HERNÁNDEZ

DIRECTOR DE TESIS:

HÉCTOR BENÍTEZ PÉREZ.

México, D.F. 2009.

1

ÍNDICE:

CAPÍTULO 1 INTRODUCCIÓN

1.1 Introducción. 1

1.2 Caso de estudio. 3

1.3 Objetivo general. 4

1.4 Metas. 5

1.5 Contribución y Relevancia. 5

CAPÍTULO 2 GENERALIDADES

2.1 Introducción al capítulo. 7

2.2 Sistemas con memoria compartida. 7

2.3 Sistemas con memoria distribuida. 12

2.4 Características de las arquitecturas referidas. 16

2.5 Sistema Multicore. 17

2.6 Métricas de desempeño en multiprocesamiento. 17

2.7 Ley de Amdahl 19

2.7 Resumen de capítulo. 21

CAPÍTULO 3 ARQUITECTURA DEL SISTEMA

3.1 Introducción al capítulo. 23

3.2 Descripción de la arquitectura de hardware. 23

3.3 Descripción de la arquitectura de software. 25

3.4 OpenMP. 29

3.5 Nivel de paralelismo. 30

3.6 Directivas y construcciones de sincronización. 32

2

3.7 MPI. 33

3.8 Llamadas utilizadas para iniciar, administrar y finalizar comunicaciones 34

3.9 Llamadas utilizadas para transferir datos entre dos procesos. 35

3.10 Llamadas utilizadas para transferir datos entre varios procesos. 36

3.11 Ventajas. 38

3.12 Desventajas. 38

3.13 Resumen de capítulo. 39

CAPÍTULO 4 CASO DE ESTUDIO

4.1 Introducción al capítulo. 41

4.2 Descripción de la red neuronal. 41

4.3 Caso de estudio 1 Implementación híbrida. 45

4.4 Caso de estudio 2 Implementación en sistemas multicore. 53

4.5 Caso de estudio 3 Implementación en serie. 56

4.6 Resumen de de capitulo. 58

CAPÍTULO 5 MÉTRICAS Y ANÁLISIS DE RESULTADOS

5.1 Introducción al capítulo. 60

5.2 Aplicación de métricas de desempeño en sistemas multicore 60

5.3 Conclusión de capítulo. 70

CAPÍTULO 6 CONCLUSIONES 72

APÉNDICE.

Código Hibrido. Utilizando las interfaces de programación MPI y OpenMP. 74

Código serial y/o Paralelo. 88

3

Referencias Bibliográficas 92

ÍNDICE DE FIGURAS.

1.1 Ejecución de instrucciones de manera secuencial. 2

1.2 Ejecución de instrucciones de manera simultánea sobre diferentes CPU’s 3

2.1 Arquitectura de procesadores con memoria compartida. 8

2.2 Diseño de una región paralela en sistemas con memoria compartida. 10

2.3 Arquitectura de un Sistema Distribuido. 12

2.4 Comunicación a través de sockets. 15

2.5 Caso ideal de aceleración para n procesadores. 19

3.1 Arquitectura híbrida de multiprocesamiento. 24

3.2 Sección Crítica. 27

3.3 Estados de los procesos en una sección crítica. 28

4.1 Algoritmo general de la Art. 44

4.2 Matriz de pesos de la red neuronal (Recurso compartido). 47

4.3 Paralelización de la red ART2A. 48

4.4 Vectores de dimensionalidad X valores mayores y posiciones correspondiente 49

4.5 Un ciclo completo de entrenamiento de la red ART2A en paralelo. 51

4.6 Hilos en acción. 53

4.7 Región paralela con hilos. 54

4.8 (a) Flujo de ejecución de hilos de manera paralela. 56

4.8 (b) Flujo de ejecución de hilos de manera concurrente. 56

4.9 Diagrama de flujo de la red ART2A de manera secuencial. 57

5.1 Aceleración de entrenamiento de la ART2A en 4 procesadores. 67

5.2 Tiempos de ciclo de ejecución del entrenamiento de la ART2A. 69

4

ÍNDICE DE TABLAS

Tabla de resultados de entrenamiento de la red neuronal ART2A con hilos (RO=0.4) 62

Tabla de resultados de entrenamiento de la red neuronal ART2A con hilos (RO=0.1) 63

Tabla de resultados de entrenamiento de la red neuronal ART2A de 3 y 4 procesadores 66

Tabla de resultados de entrenamiento de la red neuronal ART2A de 10 procesos 67

1

CAPÍTULO 1.

1.1 INTRODUCCIÓN:

Dada la necesidad de contar con máquinas de mayor potencia de proceso, hoy en día es

común encontrarse con computadoras que incluyen más de un procesador en su

arquitectura. El utilizar varios procesadores no es nuevo, ya que desde hace tiempo

existen tarjetas madre que permiten la interacción de varios procesadores (normalmente

dos, cuatro u ocho) en un solo equipo, de la misma manera como se pueden agrupar

computadoras en clúster de modo que actúen como si fuera una única computadora. Lo

que resulta realmente novedoso es que ahora los procesadores estén encapsulados en un

único chip (procesadores denominados multicore). El motivo es principalmente

económico, ya que resulta más barato producir un circuito integrado con dos

microprocesadores (dos cores), que dos procesadores independientes en una tarjeta

madre. Por otra parte, al construirse sistemas multicore se ahorra energía, se produce

menor calentamiento y al reducirse las distancias se obtiene un mejor rendimiento

(performance), que en un solo procesador de rendimiento semejante. Con un solo

procesador, una aplicación exigente pone a trabajar al tope al procesador, si existen

diversos cores, sólo trabajará al máximo el core que soporte esa aplicación, los otros

cores irán mas desahogados. Sin embargo, con los avances tecnológicos en la integración

de procesadores no solo existen cambios en su arquitectura o en su comunicación interna

sino que también conllevan un cambio en nuestra manera de pensar, ya que desde el

inicio de la era de la computadora (1945) a la fecha, los computadores secuenciales han

sido diseñados basados en el modelo introducido por John von Newman [18, 20, 21], el

cual consiste en una unidad central de proceso (CPU), una memoria, y unidades de

entrada y salida, debido a ello, el software y su programación se han orientado

tradicionalmente a la computación en serie o secuencial, de este modo es natural que los

algoritmos y programas de computadoras fueran primeramente formulados de acuerdo a

tal concepto. Aún antes de que la primera computadora electrónica fuera construida el

concepto matemático de algoritmo fue definido como una secuencia finita de operaciones

2

[22]. En una máquina secuencial, el procesador ejecuta una secuencia de instrucciones y

operan con una secuencia de datos (fig. 1.1). Para su procesamiento un problema es

dividido en un conjunto de instrucciones, y su velocidad es limitada por dos factores: la

capacidad de obtener y ejecutar dichas instrucciones y la velocidad de transferencia entre

memoria y CPU.

Instrucciones

. . .

N/N 3/N 2/N 1/N

fig. 1.1 Ejecución de instrucciones de manera secuencial.

Con el desarrollo de diversas tecnologías de interconexión entre unidades (unidades

funcionales redundantes, pipeline, paralelismo, hiperthreding, multicore, entre otras) y la

existencia de aplicaciones (científicas, técnicas, medicas, etc.) que requieren procesar

grandes cantidades de datos o realizar un alto número de operaciones, se hace necesario

el empleo de múltiples procesadores que cooperen en su ejecución, de manera que cada

aplicación se divide en un número arbitrario de subprogramas (subconjuntos de

instrucciones, o tareas independientes), con un fin determinado y estos a su vez pueden

ejecutarse simultáneamente sobre diferentes procesadores en el mismo instante de

tiempo[19] (fig. 1.2 ). Los procesadores se comunican unos con otros para intercambiar

y combinar los resultados parciales obtenidos durante su ejecución. A este modelo

tecnológico de procesamiento alternativo se le denomina cómputo en paralelo [22,3] y

pretende conseguir que N procesadores trabajen de forma conjunta para resolver un

problema N veces más rápido que en un único procesador [3]. En lugar de procesar

instrucción por instrucción como en una computadora tradicional, en un sistema de

procesamiento paralelo varias instrucciones se ejecutan simultáneamente, con el

propósito de acelerar la velocidad de procesamiento y aumentar así la eficiencia de

cómputo [19,3]. No obstante, se debe considerar que el uso de múltiples procesadores en

CPU Problema

3

un mismo sistema computacional introduce requerimientos adicionales, es decir, para que

varios procesadores puedan trabajar juntos ejecutando el mismo programa

computacional, estos deben ser capaces de compartir datos y comunicarse cada uno con

el otro, por lo que debe de haber una sincronización para así evitar condiciones de

competencia.

Problema Instrucciones

. . .

. . .

. . .

. . .

N/N 3/N 2/N 1/N

fig. 1.2 Ejecución de instrucciones de manera simultánea sobre diferentes CPUs

El presente trabajo está dirigido hacia el estudio y análisis de la programación paralela, a

tal fin se hace uso de un clúster de computadoras, cada una de ellas con arquitectura

multicore. Para la programación de estas dos arquitecturas se utiliza programación

híbrida, haciendo uso de las interfaces de programación MPI Y OpenMP. MPI

distribuye la carga entre las computadoras que conforman el clúster (comunicación inter

procesos) y OpenMP maneja los cores en una misma máquina. Cabe hacer notar que la

programación de estas dos arquitecturas es completamente diferente y requiere de

conceptos con dos visiones diferentes (se explicaran en capitulo 2).

2 1.2 CASO DE ESTUDIO.

El caso de estudio es el entrenamiento de una red neuronal llamada ART2A. Es una red

de entrenamiento no supervisado, cuya estructura consiste de dos redes neuronales

llamada ART [15, 30]. Su objetivo es la detección, localización y clasificación de

CPU 1 TAREA 1

TAREA 2

.

.

.

TAREA n

…

CPU n

CPU 2

4

defectos y fallas internas. La información proporcionada a la red para su entrenamiento,

es a través de una base de datos que contiene información suficiente de cada tipo de

defecto. La forma de entrenamiento es comparar las entradas presentes con categorías

aprendidas seleccionadas. Las categorías aprendidas se encuentran almacenadas en una

estructura multidimensional matricial llamada W [15], que es compartida por diferentes

procesos. Esta es actualizada o modificada de acuerdo a un parámetro de vigilancia (ρ),

que expresa el grado mínimo de similitud entre el vector de entrada y cualquier categoría

definida en W. Si el grado de similitud entre la entrada y cualquier categoría es mayor o

igual que ρ, entonces el prototipo actual es elegido para representar el grupo contenido.

Esto dice que la red logra resonancia. Si el grado de similitud es menor que ρ entonces

otra categoría debe ser seleccionada y comparada con el vector I (es el vector

normalizado bajo la norma Euclidiana de los datos a ser estudiados). Si cualquier

prototipo o categoría es alcanzado por el grado de similitud entonces el vector I debe ser

agregado a W como un nuevo prototipo.

1.3 OBJETIVO GENERAL.

El objetivo de este trabajo es estudiar el desempeño de sistemas con arquitectura

multicore, con base en requerimientos de acceso restringido en recursos comunes a los

procesadores, usando sistemas paralelos a través de una red de cómputo.

Se requiere distribuir el procedimiento de entrenamiento de una red neuronal de tipo

ART2A [15] en una arquitectura de multiprocesamiento que consta de N máquinas con

características Multicore. El sistema está diseñado para N procesos1 que comparten una

Red Neuronal ART2A. Este recurso debe ser actualizado o modificado dependiendo de

los resultados del entrenamiento de la propia red en cada uno de los procesos. Para medir

el desempeño de un programa ejecutándose en este tipo de arquitecturas se hace uso de la

Ley de Amdahl para sistemas distribuidos [23] y el Vtune (analizador de rendimiento) en

sistemas multicore.

1 Proceso. Un proceso se define como un programa en ejecución.

5

1.4 METAS.

Desarrollar un sistema de doble multicore con base a una red tipo Ethernet y dos

sistemas Multicore. Esto es conectando dos máquinas con arquitectura core a

través de una red de computadoras.

Crear un algoritmo paralelo híbrido en lenguaje de programación C++, en el que

se implementarán las librerías de MPI y OpenMp.

Distribuir la carga de trabajo de manera equitativa entre los procesadores

tomando en cuenta el acceso a memoria de estos (multiprocesadores o multi-

computadores).

Evaluar el desempeño de estos sistemas así como determinar potenciales

condiciones de competencia entre los procesos.

1.4 CONTRIBUCIÓN Y RELEVANCIA.

En el desarrollo de la presente tesis se abordó el problema de paralelización del método

de entrenamiento no supervisado ART2A para redes neuronales [15, 30]. Como es bien

sabido este tipo de entrenamiento tiene importantes aplicaciones, por ejemplo, en teoría

del control, robótica, reconocimiento de patrones, entre otras.

El enfoque con el que se abordó este problema fue mediante el uso de

multiprocesamiento híbrido en el que se emplean los esquemas de paralelización de

memoria compartida (SMP) [3,5] y paso de mensajes en arquitectura distribuida

(MPI)[13].

Para determinar el rendimiento de ejecución del programa híbrido en múltiples

procesadores se utilizaron funciones de métricas de tiempo proporcionadas en las

librerías del lenguaje de programación C++ [1].

6

Las afirmaciones que podemos deducir de los resultados obtenidos en los experimentos

realizados con la implementación mencionada son los siguientes:

1. En el algoritmo ART2A existe una gran cantidad de dependencia de datos

inherentes al mecanismo de aprendizaje en el entrenamiento. Esto induce al

hecho de que en la paralelización de dicho algoritmo siempre exista una porción

de código no paralelizable, que aunque se encontró como una fracción pequeña,

esta porción nos impide escalar el procedimiento de paralelización a un número

arbitrario de procesadores [11, 23]. Tenemos entonces que el uso de varios

procesadores y procesos no es garantía de un manejo eficiente en el

procesamiento de la información. De hecho el análisis de resultados obtenidos

durante la ejecución de los programas en donde empleamos ambas arquitecturas

(explicadas en las secciones 1.2 y 1.3) determinará la mejor aproximación para

la paralelización en cuanto al flujo propio de la información.

2. Cuando la dimensión de los vectores de entrenamiento es alta, entonces la

dependencia de datos en las operaciones internas del procedimiento ART2A

disminuye, por ejemplo, la multiplicación de matriz por vector, producto interno,

y normalización de vectores, pueden entonces descomponerse en procesos

paralelos obteniendo así un mejor rendimiento que en el caso secuencial.

Remarcamos el hecho de que esto ocurre cuando la dimensión de los vectores es

alta, pues de otra manera, el tiempo procesamiento de las instrucciones

adicionales para conseguir paralelismo superará al tiempo ganado por el proceso

de paralelización.

En resumen, pudimos observar en los experimentos, que aunque es posible paralelizar el

procedimiento ART2A es necesario verificar si la dimensionalidad de los vectores de

entrenamiento, así como también el numero de vectores clasificados en W. La dimensión

de estos nos permitirá mejorar o no el rendimiento del proceso. En resumen: el tamaño

de los datos a paralelizar es un factor muy importante a considerar en la programación

paralela.

7

CAPÍTULO 2. GENERALIDADES:

2.1 INTRODUCCIÓN AL CAPÍTULO.

En este capítulo se describen las características de las tecnologías empleadas para

abordar el cómputo paralelo, la forma en que se comunican e intercambian información,

así como también la manera de sincronización en ambos arquitecturas. Se explica lo que

es un sistema multicore y algunas de las métricas de desempeño para evaluar el

rendimiento de un programa al ejecutarlo en múltiples procesadores.

Para implementar el modelo de cómputo paralelo se consideran dos tipos de

arquitecturas ampliamente utilizadas, las cuales difieren en la forma en la que se

comunican los procesadores [22, 6]:

Sistemas con memoria compartida: En una aplicación paralela lo que se pretende es

ejecutar un programa más rápidamente que en una versión secuencial, para ello lo que se

hace es utilizar varios procesos, que ejecutan partes de un mismo programa, de tal manera

que el tiempo empleado en la ejecución paralela de todos ellos sea menor que el tiempo

empleado por un único proceso en resolver el problema [18].

Sistemas con memoria distribuida): En una aplicación distribuida existen diferentes

procesos, que ejecutan distintas partes de un programa, dichos procesos colaboran y se

comunican entre sí para alcanzar un mismo objetivo.

2.2 SISTEMAS CON MEMORIA COMPARTIDA “MULTIPROCESADOR”

Consiste en un número de procesadores idénticos dentro de una misma máquina

compartiendo una memoria principal global [3,22]. (fig. 2.1).

8

BUS

. . .

(fig. 2.1). Arquitectura de procesadores con memoria compartida.

El acceso a la memoria principal global es a través de un bus. El bus es el canal de

comunicación para llevar a cabo las operaciones de solicitud de memoria simultánea por

varios procesadores y asegurar que todos los procesadores sean justamente atendidos con

un mínimo retardo de acceso. El encargado de arbitrar las tareas, sus prioridades y

recursos disponibles es el Sistema Operativo. Una de las mayores dificultades en

sistemas de multiprocesamiento de memoria compartida es la competencia por recursos,

principalmente por el acceso a memoria entre los procesadores [3]. Esta se incrementa

conforme el número de procesadores sea mayor y más procesos activos se tengan en el

sistema. A mayor grado de multiprogramación se presentan mayores necesidades de

memoria. Cuando varios procesadores intentan accesar a la memoria compartida dentro

del un periodo de tiempo pequeño, la memoria no le es posible atender todas las

peticiones simultáneamente, por lo que algunos de los procesadores tendrán que esperar

mientras otros son atendidos [3, 6, 21].

La programación eficiente en este tipo de arquitecturas se realiza mediante el control de

hilos paralelos. Un hilo (thread) es un flujo de control independiente dentro de un

proceso. Es esencialmente una ruta de ejecución a través del código de programa en

proceso (fig. 2.2). Los hilos dentro de un mismo proceso suelen compartir los recursos

asignados al proceso al cual pertenecen. La manera de identificar un hilo dentro de un

proceso es por su identificador (ID) que es un valor entero único dentro de cada proceso.

MEMORIA

COMPARTIDA

PROCESADOR

2

PROCESADOR

1

PROCESADOR

n

9

Dos hilos en diferentes procesos pueden tener el mismo número de ID. Sin embargo, cada

uno realizará operaciones diferentes.

Con procesadores multicore se reparten los diferentes hilos entre los cores, de modo que

varias aplicaciones avanzan a la vez, permaneciendo menos tiempo en espera, logrando

con ello agilizar la ejecución de una tarea [3,22]. Debido a que los hilos dentro de un

mismo proceso comparten las mismas direcciones físicas de memoria, estos comparten

las mismas estructuras y datos a nivel proceso, sin embargo, cada hilo tiene información

propia que no comparte con otros hilos. Esta información se refiere fundamentalmente

al contexto de ejecución, pudiéndose destacar los siguientes datos:

Contador de programa.

Tope de pila.

Estado de registros.

Estado del hilo (thread).

El estado de un hilo (listo, activo, bloqueado) en cualquier instante está definido por el

proceso en memoria. Cada procesador ejecuta un hilo diferente, aunque cualquier hilo

podría estar corriendo en cualquier procesador en cualquier momento. En un sistema de

dos procesadores cada procesador puede estar corriendo diversos hilos, los cuales pueden

pertenecer al mismo proceso o a diferentes procesos. Un hilo o proceso no está atado o

ligado a un procesador particular. Esto lo determina el Sistema Operativo.

Para un uso eficiente en esta arquitectura se propone el empleo de múltiples hilos

(multithreads MT), ya que si se tiene un solo hilo esperando por los recursos del sistema

no se hace uso adecuado del hardware. Si el hilo tiene que hacer cálculos extensivos

entonces todas las demás aplicaciones tendrían que esperar. El usar multihilos puede

remover los cuellos de botella. Un programa MT comienza con un hilo inicial,

denominado hilo maestro. Este hilo inicial crea nuevos hilos, que son considerados hilos

esclavos. (fig 2.2)

10

Región Paralela

Hilo Maestro Hilo Maestro

Fig. 2.2 Diseño de una región paralela. El hilo maestro crea hilos esclavos

Los nuevos hilos corren una rutina independiente y suministran otras corrientes de

instrucciones operativas en el mismo espacio de direccionamiento de datos. El Sistema

Operativo se ocupa de asegurar que cada hilo se mantenga activo. Esto lo hace con la

asistencia del hardware y una gran cantidad de registros de transacciones. Cuando el

temporizador del hardware decide que un proceso ha estado ejecutándose por suficiente

tiempo entonces ocurre una interrupción2. El Sistema Operativo salva el estado actual del

hilo mediante la copia de los registros del hilo desde la pila hacia una estructura de

contexto y la guarda para su uso posterior. Para cambiar hacia diferentes hilos el Sistema

Operativo direcciona el procesador a la memoria correspondiente al hilo del proceso,

luego restaura los registros que fueron guardados en la estructura de contexto en un

nuevo hilo. A este proceso es llamado intercambio de contexto (context swich)

[4,5,18]. No hay que olvidar que el crear hilos y hacer intercambios de contexto le toma

una cantidad finita de tiempo al procesador por lo que al momento de crear hilos se debe

tomar en cuenta cuantos hilos se van a manejar en la aplicación paralela y asegurar que

no exista una sobrecarga en intercambio de contextos. De no tomar en cuenta esto, se

puede consumir mayor tiempo con múltiples hilos al ejecutar el código. Todo esto debido

al intercambio de contexto y a la introducción de instrucciones propias del modelo

paralelo que no son necesarias en el programa secuencial.

2 A nivel físico, una interrupción se solicita activando una señal que llega a la unidad de control.

Ante esta solicitud, la unidad de control realiza un ciclo de aceptación de interrupción. Este ciclo

se lleva a cabo cuando termina la ejecución de la instrucción máquina que se está ejecutando y

consiste en las siguientes operaciones: 1. Salva algunos registros del procesador, como son el de

estado y el contador de programa (CP). 2. Eleva el nivel de ejecución pasándolo al núcleo 3. Carga

un nuevo valor en el CP por lo que pasa a ejecutar otro programa.

11

Otro aspecto es el control de condiciones de competencia. Una condición de

competencia ocurre cuando varios hilos compiten por un mismo recurso. Para prevenir

dichas condiciones y evitar que los hilos sean interrumpidos mientras se encuentran

haciendo alguna operación cuya integridad es indispensable en un procedimiento, es

necesario protegerlos. Esto se hace mediante mecanismos de sincronización, que no son

más que la manera de coordinar los hilos para que puedan trabajar en conjunto. La

sincronización entre hilos se realiza mediante variables globales compartidas que pueden

ser coordinadas usando secciones críticas, semáforos o mutex. Una Sección Crítica (SC)

es una porción de código que accesa a un recurso compartido y que solo a un hilo a la vez

se le permite entrar a ejecutar dicho código, convirtiéndose en una operación atómica3.

Cada hilo debe pedir permiso para entrar a la sección crítica, mediante algún fragmento

de código que se denomina de forma genérica entrada en la sección crítica. Cuando un

hilo sale de la sección crítica debe indicarlo mediante otro fragmento de código, que se

denomina salida de sección critica. Mediante la utilización de Mutex (exclusión mutua) si

un hilo se encuentra en la SC, ningún otro podrá entrar. Un semáforo es un objeto que

permite controlar el acceso a un recurso compartido. Está compuesto de un contador y de

una cola de espera. Cuando el contador es positivo, indica que existen recursos

disponibles. Cuando es negativo indica la cantidad de procesos o hilos que esperan por el

recurso [3, 4, 18.].

Un ejemplo de condición de competencia ocurre cuando varios hilos hacen despliegue de

datos en pantalla. Debido a que el Sistema Operativo sólo le proporciona cierta cantidad

de tiempo a cada hilo, los hilos compiten por el recurso. Un determinado hilo empezará a

hacer su despliegue, pero al transcurrir el tiempo asignado para su ejecución, si aún no

ha terminado de hacer su despliegue, el control del dispositivo de despliegue le será

quitado y se transferirá a otro hilo, teniendo como resultado una potencial inconsistencia

en los datos desplegados.

3 Una operación atómica es una porción de código que no puede ser interrumpida mientras esta en

ejecución.

12

2.3 SISTEMAS CON MEMORIA DISTRIBUIDA “MULTICOMPUTADORA”.

Un sistema Distribuido se define como un grupo de computadoras separadas

físicamente.Cada máquina tiene su propia memoria y sólo se comunican entre ellas por

medio de mensajes a través de una red de computadoras [3,18]. Cada una de las

computadoras conectadas a la red posee sus componentes de hardware y software

que el usuario percibe como un solo sistema. (fig. 2.3),

fig. 2.3 Arquitectura de un Sistema Distribuido. Cada máquina tiene su propio

procesador (P) y memoria (M) y se comunican por medio de mensajes a través de una red

de computadoras.

PASE DE MENSAJES

COMUNICACIÓN A

TRAVÉS DE LA RED

P

M

P

M

P

M

P

M

P

M P

M

13

Un Sistema Distribuido se define según dos puntos de vista:

1. Desde un punto de vista físico, un sistema distribuido es un conjunto de

procesadores (posiblemente heterogéneos), sin memoria ni reloj común, que se

encuentran conectados a través de una red de interconexión. fig. 1.4 [3, 21, 22].

2. Desde el punto de vista lógico, un sistema distribuido es un conjunto de procesos

que no comparten recursos y que se ejecutan en una o más computadoras y que

colaboran y se comunican entre ellos mediante el intercambio de mensajes.

De estos dos puntos de vista se desprende que uno de los aspectos más importantes de un

Sistema Distribuido es comunicar diferentes procesos entre sí con independencia del

lugar donde se ejecuten.

La plataforma fundamental sobre la que se construyen los sistemas distribuidos es una

red de computadoras, lo cual permite que puedan compartir diferentes recursos como son:

periféricos, datos o incluso procesadores. Una red de computadoras es un sistema de

comunicación compuesto por una serie de componentes hardware y software que

proporcionan los servicios necesarios para que los procesos que ejecutan en las distintas

computadoras puedan comunicarse entre sí. En este tipo de arquitectura, puesto que los

diferentes procesadores no comparten una memoria común, la única forma de

comunicación posible es mediante el intercambio de mensajes. Un mensaje es un objeto

lógico que se intercambia entre dos o más procesos. Para transmitir un mensaje a través

de una red de interconexión es necesario descomponerlo en una serie de paquetes. Un

paquete es la unidad de información que se intercambian dos dispositivos de

comunicación. Para que la comunicación se lleve a cabo, es necesario el empleo de

protocolos de comunicación. Un protocolo es un conjunto de reglas e instrucciones que

gobiernan el intercambio de paquetes y mensajes.

Utilizando pase de mensajes como mecanismo de comunicación entre procesos,

únicamente existir un enlace de comunicación entre ellos. Los procesos se comunican

mediante dos operaciones básicas:

14

send(destino, mensaje): envía un mensaje al proceso destino.

receive(origen, mensaje): recibe un mensaje del proceso origen.

La comunicación entre los procesos es de manera directa o indirecta, es decir, deben tener

una forma de referirse a cada uno de ellos. Sin embargo, cualquiera que sea el método

utilizado, el paso de mensajes siempre se realiza en exclusión mutua.

La comunicación entre dos procesos es síncrona cuando los dos procesos han de ejecutar

los servicios de comunicación al mismo tiempo, es decir, el emisor debe estar ejecutando

la operación send y el receptor ha de estar ejecutando la operación receive. La

comunicación es asíncrona en caso contrario.

Existen tres combinaciones más habituales que implementan los distintos tipos de paso de

mensajes:

Envío y recepción con bloqueo: En este caso, tanto el emisor como el receptor se

bloquean hasta que tenga lugar la entrega del mensaje. Esta es una técnica de

paso de mensajes totalmente síncrona.

Envío sin bloqueo y recepción con bloqueo: Esta es la combinación generalmente

más utilizada. El emisor no se bloquea hasta que tenga lugar la recepción y por

tanto puede continuar su ejecución. El proceso que espera el mensaje, sin

embargo, se bloquea hasta que llega.

Envío y recepción sin bloqueo: Se corresponde con una comunicación

totalmente asíncrona en la que ningún proceso espera.

Existen dos modelos muy utilizados para el desarrollo de aplicaciones cliente-servidor en

sistemas distribuidos: Los sockets y las llamadas a procedimientos remotos.

1. Los sockets aparecieron en 1981 en la versión BSD 4.2 de UNIX [18]. Un socket

es una abstracción que representa un extremo en la comunicación bidireccional

entre dos procesos. Ofrece una interfaz para acceder a los servicios de red en el

nivel de transporte de los protocolos TCP/IP. Utilizando esta interfaz, dos

procesos que deseen comunicarse deben crear un socket o extremo de

15

comunicación cada uno de ellos. Cada socket se encuentra asociado a una

dirección y permite enviar o recibir datos a través de él. (fig. 2.4)

Máquina A Máquina B

2.4 Comunicación a través de sockets

En una llamada a procedimiento remoto (RPC, Remote Procedure Call) [Birrel, 1984], el

programador no necesita preocuparse de cómo realiza la comunicación entre procesos.

Simplemente realiza llamadas a procedimientos que serán ejecutados en computadoras

remotas. En este sentido el programador desarrolla sus aplicaciones en forma

convencional descomponiendo su software en una serie de procedimientos bien

definidos. En una RPC, el proceso que realiza la llamada empaqueta los argumentos en

un mensaje, se los envía a otro proceso y espera resultado. Por su parte, el proceso que

ejecuta el procedimiento extrae los argumentos del mensaje, realiza la llamada de forma

local, obtiene el resultado y se lo envía de vuelta al proceso que realizó la llamada. Este

proceso es totalmente transparente al usuario.

La sincronización de procesos en sistemas distribuidos es más complicada que en

sistemas con memoria compartida, debido a que los procesos no comparten una memoria

ni un reloj global común. Esto dificulta la forma de ordenar los eventos que ocurren en un

sistema distribuido y la resolución de problemas de sincronización clásicos como los

descritos en la sección 2.2. En un sistema con memoria compartida, la ordenación de

eventos es un problema trivial puesto que existe un reloj físico común que permite

proceso

socket

NÚCLEO

envía

proceso

socket

NÚCLEO

recibe

R E D

16

determinar que evento ocurrió antes que el otro. Esto no ocurre de igual manera en un

sistema distribuido puesto que cada computadora dispone de su propio reloj. Una forma

de ordenar eventos en sistemas distribuidos que carecen de un reloj global es utilizar el

concepto de relojes lógicos propuesto por Lamport en 1978. Este concepto se basa en la

relación de precedencia definida también por Lamport en 1978. Según Lamport, no es

necesario recurrir a un reloj físico global para asegurar el orden de eventos en un sistema

distribuido. Basta con asignar unas determinadas marcas lógicas de tiempo a los eventos

[25].

2.4 CARACTERÍSTICAS DE LAS ARQUITECTURAS REFERIDAS

La diferencia más importante entre un sistema distribuido y un sistema con

memoria compartida es el acceso a memoria y por ente la comunicación entre

procesos.

Los sistemas con memoria compartida permite dividir las aplicaciones en varias

tareas, lo que beneficia la modularidad y con ello disminución en tiempo de

ejecución. Por tanto puede atender a varios usuarios de forma eficiente,

interactiva y simultánea.

Una de las características más importantes de los sistemas con memoria

compartida es ahorro en el tiempo de proceso, ya que la información entre los

cores viaja en el bus interno, que siempre es más rápido que cualquier bus

externo, además de ahorro en energía

En los sistemas de memoria distribuida una de las características más importantes

es que se tiene la capacidad de crecimiento. Es relativamente fácil que un sistema

distribuido crezca para adaptarse a las nuevas demandas de servicio, basta con

conectar más computadoras a la red. Por otra parte, si un circuito de un

procesador falla, a lo más afectará a un nodo conectado a la red, por lo que no

afecta a la ejecución del sistema. Con sistemas de memoria compartida, la falla

de un circuito afecta de manera potencial la ejecución del sistema.

17

2.5 SISTEMAS MULTICORE:

El empleo de varios procesadores dentro de una sola máquina no es un concepto nuevo.

Desde hace tiempo, las tarjetas madre de algunos equipos han permitido utilizar varios

procesadores, normalmente dos o cuatro. Así también se tiene que se ha hecho uso de

computadoras en clúster, de modo que todos actúen como si fueran una única

computadora. La novedad introducida con las nuevas tecnologías es que ahora los

procesadores estén montados sobre un único chip, con 2, 4, 6 u hasta 8 núcleos dentro

del mismo encapsulado. El motivo principal para esto es la economía, pues resulta más

barato producir ordenadores con dos cores que dos procesadores independientes en una

misma tarjeta. Además, se produce un ahorro en el tiempo de proceso, ya que la

información entre los cores viaja en el bus interno, que siempre es más rápido que

cualquier bus externo.

Con sistemas multicore, se reparten las diversas tareas entre los diferentes cores, de

manera que varias aplicaciones avanzan a la vez, permaneciendo menor tiempo posible

en espera del control del procesador. La tarea de repartir los programas entre los

diferentes cores es realizada por el sistema operativo, por lo que al no depender de las

aplicaciones, cualquier programa, sea antiguo o actual funciona sin problema en un core.

Otra de las ventajas de sistemas multicore es el ahorro de energía. Con un único

procesador, una aplicación exigente pone a trabajar al tope al procesador, generando gran

cantidad de calor. Si existen diferentes cores, solo trabajará al máximo el core que

soporte esa aplicación en un determinado momento. Los otros tendrán una menor carga,

lo que en conjunto hace que se disipe menos energía [11,3].

2.6 MÉTRICAS DE DESEMPEÑO EN MULTIPROCESAMIENTO.

Existen diversas formas de medir el desempeño de un algoritmo paralelo corriendo sobre

procesadores paralelos. Las medidas más comúnmente usadas son: el tiempo de

ejecución, precio/desempeño, el speed-up (aceleración) y la eficiencia [23].

18

La métrica más importante para correr un trabajo sobre una máquina dada es el tiempo de

ejecución.

Precio/desempeño de un sistema paralelo es simplemente el tiempo transcurrido por un

programa dividido por el costo de la máquina que corrió el trabajo.

El Speed-up (Sc) y la eficiencia son las medidas más frecuentemente usadas para conocer

que tan eficientemente se está utilizando.

El Sc (aceleración) es la medida generalmente usada: Para obtenerla se ejecuta el mismo

programa sobre un variado número de procesadores. El Sc es entonces el tiempo

transcurrido en un programa secuencial por un procesador dividido entre el tiempo de ese

mismo programa paralelo en n procesadores. Así la aceleración Sc para n procesadores se

define como:

Sc = Ec. 2.1

Donde:

= Tiempo de ejecución del programa secuencial en un único procesador.

= Tiempo de ejecución del programa paralelo en n procesadores.

La eficiencia E de un programa es la razón entre la aceleración de un programa y el

número de procesadores utilizados para la ejecución del mismo.

E = Ec. 2.2

La eficiencia está relacionada con la fracción de tiempo que un procesador está siendo

utilizado para ejecutar el programa. Idealmente si n procesadores utilizan el 100 % de su

tiempo solamente para operaciones de computación, la eficiencia será igual a 1. Pero

como un programa paralelo requiere comunicación entre procesadores, parte del tiempo

19

de los procesadores es consumido por esta actividad, llevando a valores de eficiencia

menor a 1 (E<1).

Idealmente se espera que el sc crezca linealmente y la E = 1 para todo n.

Existen casos donde Sc es superlineal o sea que k procesadores resuelven una tarea en

menos que un k-esimo del tiempo de corrida secuencial.

Speed-up (sp) Lineal (ideal)

Super lineal

Típico.

Fig. 2.5 Caso ideal de aceración para n procesadores.

2.7 LEY DE AMDAHL

Una de las maneras de saber el rendimiento de nuestra aplicación paralela es la aplicación

de la Ley de Amdahl [3, 11, 23]. El incremento de velocidad de un programa utilizando

múltiples procesadores en computación distribuida está limitado por la fracción

secuencial del programa, es decir, aquélla que independientemente de cuantos

procesadores se tengan para ejecutar el programa, solo puede ser realizada por uno solo

de ellos; el resto del cálculo no podrá continuar hasta que se haya completado tal parte

secuencial.

La Ley de Amdahl propone normalizar el tiempo que toma realizar la operación en un

solo procesador al valor de 1. La fracción del cálculo que se puede realizar

Procesadores (n)

20

secuencialmente será (1-P), y la parte paralelizable es P. Con estos datos, el incremento

de velocidad máximo que puede obtenerse con n elementos de procesamiento está dado

por la siguiente ecuación:

Sc = Ec. 2.3

Como un ejemplo, si nuestra aplicación no tiene sección secuencial (es decir 1-P) y (la

parte serializada) P=1, entonces el incremento de velocidad estará dado exactamente por

el número de elementos de procesamiento:

=n Ec. 2.4

Por otra parte, si el 50% del código es secuencial es decir (1-P)=0.5 la ecuación

queda:

+ Ec. 2.5

Suponiendo un número infinito de procesadores, esta ecuación da como resultado

dos. Si el 50% del código es secuencial, por más procesadores que se agreguen el

rendimiento nunca será mayor que 2 veces con respecto a una implementación en

un único procesador.

Así pues, la Ley de Amdahl establece un concepto esencial para la planeación y

utilización de cualquier tipo de máquina paralela: el incremento en velocidad que

podemos obtener está limitado por el algoritmo que emplee nuestra aplicación, y

no por el número de procesadores. Si el problema lo permite, se debe buscar

implementar programas que tengan la menor cantidad de código secuencial,

21

debido a que este factor tiene mucha más importancia que el número de

procesadores a utilizar.

2.8 RESUMEN DE CAPÍTULO.

Para que varios procesadores sean capaces de trabajar juntos sobre el mismo problema

computacional, deben ser capaces de compartir datos y comunicarse cada uno con otro.

A lo largo de este capítulo se han expuesto dos arquitecturas especializadas cumpliendo

estos requerimientos: Sistemas con memoria compartida y Sistemas con memoria

distribuida.

La principal diferencia en estas dos arquitecturas es el acceso a memoria. En

computadoras con memoria compartida (multiprocesadores) todos los procesadores

tienen acceso a una memoria principal global, por lo que comparten el mismo espacio de

direcciones. La comunicación en estas arquitecturas es a través de variables globales y la

programación eficiente es mediante el manejo de múltiples hilos. Sin embargo, una de

las mayores dificultades es la coordinación en el acceso a los recursos, ya que un recurso,

solo puede ser poseído por un solo hilo a la vez. Para evitar que más de un hilo accese a

un mismo recurso y prevenir inconsistencia de datos es necesario emplear mecanismos de

sincronización, lo cual hace que los hilos se coordinen para decidir en qué momento que

hilo tiene derecho a ejecutarse y así prevenir condiciones de competencia.

En sistemas con memoria distribuida, tanto la sincronización como la comunicación es

por medio de mensajes enviados a través de la red. La comunicación es entre proceso y

puede ser de manera directa o indirecta, es decir, deben tener una forma de referirse a

cada uno de ellos. El paso de mensajes siempre se realiza en exclusión mutua, teniendo

en cuenta los mecanismos de sincronización (síncrona o asíncrona). Debido a que en este

tipo de arquitectura no existe un reloj común entre los procesadores la coordinación entre

eventos es por medio de relojes lógicos (propuesto por Lamport) [25].

Además de la diferencia en acceso a memoria, existe un punto muy importante a

recordar: en una aplicación distribuida lo que se hace es dividir un problema en varios

procesos para que cooperen en la solución de éste, en una aplicación paralela lo que se

22

pretende es acelerar el procesamiento, por lo que el proceso puede ser dividido en tareas

más granulares y cada una seguir un flujo de ejecución diferente, reuniendo al final

resultados obtenidos. Tener recursos compartidos y gran cantidad de comunicación le

resta eficiencia a la programación en estas arquitecturas.

23

CAPÍTULO 3. ARQUITECTURA DEL SISTEMA

3.1 INTRODUCCIÓN AL CAPÍTULO.

En este capítulo se describe la arquitectura de hardware y software para hacer la

implementación de cómputo paralelo. Se da una breve descripción de la interfaz y los

pragmas utilizados para realizar paralelismo en cada una de las arquitecturas

mencionadas, así como también las ventajas y desventajas que se presentan durante su

uso.

3.2 DESCRIPCIÓN DE LA ARQUITECTURA DE HARDWARE.

Para la construcción física del sistema propuesto se integran dos máquinas multicore con

base a las interfaces de programación MPI y OpenMP. MPI para distribuir la carga entre

los nodos que conforman el clúster y OpenMP para el manejo de hilos entre los

procesadores en una misma máquina.

Se establece un caso de estudio que permite determinar regiones críticas en el acceso a un

recurso común que impone las restricciones en tiempo necesarias y permite visualizar la

potencial serialización entre procesos. El recurso común es una matriz de pesos de la red

neuronal ART2A llamada W.

El programa está diseñado para su ejecución en N máquinas agrupadas en un clúster de

alto rendimiento. En la práctica, para realizar los experimentos de desempeño se

utilizaron dos máquinas conectadas entre sí a través de una interface de red del tipo LAN

a una velocidad de 100 Mbps. Cada máquina está equipada con un procesador Intel Core

2 Duo que es capaz de ejecutar 2 hilos paralelos simultáneamente mediante el uso de dos

núcleos [3,8]. La plataforma del sistema operativo utilizado es Windows XP de 32 bits.

La herramienta utilizada para hacer trabajar estas dos máquinas como un clúster es MPI

[3,7,13], con esto tenemos la capacidad de controlar cada uno de los procesos

participantes en la ejecución del programa y direccionarlos hacia cualquiera de los dos

equipos. La arquitectura de hardware se representa en la figura 3.1.

24

Fig. 3.1 Arquitectura híbrida de multiprocesamiento.

Para aprovechar la arquitectura multicore se utiliza el estándar OpenMP. El esquema de

programación en tales arquitecturas se realiza mediante el control de hilos. Haciendo uso

de las directivas de OpenMP en el programa, solo hay que identificar la región que no

tiene dependencia de datos y puede ser paralelizada para ser ejecutada por múltiples hilos

[3,4,5,6,10]. Esto sin olvidar sincronizar el trabajo de los hilos para evitar condiciones de

competencia [18,21]. Debido a que los sistemas multicore cuentan con la característica

de compartir memoria, se dividen las operaciones dentro de cada proceso entre los

núcleos (cores) con que cuenta el sistema.

Para el desarrollo del código de este programa se utilizó el IDE (Integrate Development

Environment) Microsoft para la programación en lenguaje C++ y el compilador de Intel

ICC (Intel Compiler Colection) para obtener la funcionalidad de las directivas de

OpenMP. Como herramienta de desempeño se utiliza la librería estándar time.h del

OpenMP

CPU

2

MEMORIA

PRINCIPAL

1

CPU1

OpenMP

CPU

2

MEMORIA

PRINCIPAL

1

CPU

1

MPI MPI

RED

25

lenguaje C para analizar el comportamiento que toman los hilos y su mejora con respecto

a ese mismo programa de manera secuencial. Así mismo se hace uso de las métricas de

desempeño como es la ley de Amdahl.

Los resultados parciales obtenidos en cada proceso son comunicados a un proceso

maestro dentro de la red. Este coordina a los procesos trabajadores y evalúa los

resultados que le son comunicados por la interfaz MPI a través de la red. También envían

una respuesta a los procesos trabajadores, indicándoles el procedimiento a seguir para la

actualización o incorporación de un nuevo vector al recurso compartido.

Haciendo uso de ambas arquitecturas (descritas en la sección 2.2 Y 2.3) se puede

observar el desempeño del sistema y su rendimiento en base a métricas de tiempo. Esto es

evaluando el tiempo consumido al final de cada uno de los procesos, así como los

recursos de comunicación a través de la red empleados en promedio.

3.3 DESCRIPCIÓN DE LA ARQUITECTURA DE SOFTWARE.

En los sistemas distribuidos, debido a la ausencia de memoria compartida, toda la

comunicación y mecanismos de sincronización se basa en la transferencia de mensajes.

Esta es la parte fundamental y básica en cualquier sistema distribuido. Tal sistema tiene

la característica de poder compartir recursos como son: hardware, software o datos. Sin

embargo, para obtener un buen rendimiento, es importante reducir la latencia4 de las

comunicaciones ya que estas afectan en gran medida al rendimiento. Otro aspecto a tener

en cuenta para mejorar el rendimiento es evitar la existencia de cuellos de botella o

recursos centralizados en el sistema. Para que el sistema pueda crecer, el sistema

operativo debe evitar la existencia de componentes centralizados. En los sistemas de

memoria compartida, la comunicación y sincronización es a través de variables globales

4 Latencia: Mide el tiempo necesario para transferir un mensaje vacio. La latencia contabiliza la

sobrecarga introducida por el software de comunicaciones.

26

compartidas. Para lograr que varios hilos participen en la solución de un mismo

problema, es necesario emplear mecanismos de sincronización, es decir, la manera de

coordinar para accesar a un recurso compartido y con ello evitar inconsistencia de datos,

esto se realiza a través de fragmentos de código que se denomina sección crítica. Para

que un hilo pueda entrar a una sección crítica este debe pedir permiso, de igual manera

cuando sale debe notificar para que los demás que están en espera de accesar y ejecutar

su parte correspondiente puedan accesar. La estructura por tanto, de cualquier mecanismo

que pretenda resolver el problema de la sección es la siguiente:

Entrada en la sección crítica

Código de la sección crítica

Salida de la sección crítica

Una forma representativa de dicho mecanismo es el diagrama 3.2, donde se puede

observar que una sección crítica es una barrera que protege a un recurso compartido, y

para que cada uno de los hilos pueda accesar a dicho recurso debe pedir permiso de

entrar. Una vez que un hilo entre a ejecutar código de la sección crítica bloquea el

acceso, y ningún otro podrá entrar, hasta que el hilo que la posee salga de ella. Este

acceso se controla en la sección crítica mediante un mutex o un semáforo. Sin embargo,

el problema está en cómo extender un orden parcial a un ordenamiento total y arbitrario,

usándolo en la resolución de problemas de sincronización.

27

Como se puede observar en las figura 3.2 y 3.3, dentro de la sección crítica los procesos

pueden estar accediendo y modificando variables comunes, registros de Bases de Datos,

algún archivo, etc. En general cualquier recurso compartido. La característica más

importante es que cuando un proceso se encuentra ejecutando código de la sección

crítica, ningún otro proceso se puede ejecutar su sección. Esto es debido a que cuando un

proceso entra, la sección crítica se bloquea. Los demás procesos que necesiten accesar a

dicha sección quedarán en espera hasta que el proceso la libere. Y así sucesivamente,

hasta que no exista proceso alguno esperando por el recurso protegido por la sección

crítica.

Fig. 3.2 Sección Crítica. Solo un hilo a la vez puede ejecutar el código; los demás quedan en

espera de la liberación.

SALIDA DE LA SECCIÓN CRÍTICA

(puede accesar el siguiente proceso en

espera)

MECANISMOS DE ACCESO A LA

SECCIÓN CRÍTICA (MUTEX, SEMÁFORO)

CÓDIGO DE LA SECCIÓN CRÍTICA

ACCESO A RECURSO

COMPARTIDO

SOLO UN PROCESO

A LA VEZ

Lista de procesos en espera

de accesar a la Sección

crítica.

0 1 2 3 n

28

La forma típica en la que una sección crítica protege datos compartidos por múltiples

procesos ejecutándose simultáneamente es la Figura 3.3

Por ejemplo, cuando un proceso escribe nuevos datos a un elemento dentro de un arreglo

y actualiza el índice máximo de este arreglo, puede ocurrir una inconsistencia si

consideramos que otro proceso corriendo simultáneamente en otro procesador trabajando

sobre el mismo arreglo realiza algún cálculo sobre cada elemento en el arreglo. Si el

segundo proceso ve el nuevo valor del índice antes que el arreglo contenga un dato válido

entonces el cálculo es incorrecto. La definición de una sección crítica es una solución

general a este tipo de problema. Por lo que solamente un proceso está ejecutando dicha

sección crítica de código a la vez. La notificación de este estado será comunicada

mediante un bloqueo. El siguiente diagrama de tiempo muestra tres procesos

compartiendo los mismos datos que son manipulados dentro de una sección crítica del

código.

Fig. 3.3 Estados de los procesos en una sección crítica (ejecutándose y en espera).

Sección

crítica

espera

ejecutando

Proceso 3

Proceso 1

Proceso 2

Proc. 1 bloquea

Proc. 2 espera

Proc. 2 bloquea Proc. 3 bloquea

Proc. 3 espera

Proc. 1 libera Proc. 2 libera

Tiempo

29

Solo a un proceso a la vez se le permite ejecutar el código de la sección crítica,

convirtiéndose con ello en una operación atómica. Si ningún proceso está ejecutando

dentro de la sección crítica, la decisión de qué proceso entra en la sección se hará sobre

los procesos que desean entrar. Además esta decisión debe realizarse en tiempo finito.

TIPOS DE COMUNICACIÓN.

3.4 OpenMP

Para hacer la paralelización de hilos en cada uno de los procesos, se utilizan las directivas

de OpenMP. Las librerías OpenMp proporcionan una forma rápida y eficiente para dar

soporte a la programación multihilos, sin tener que considerar los detalles internos del

funcionamiento de los hilos en determinado sistema operativo. Esto permite al

programador enfocarse en el diseño sin tener que ocuparse de la implementación a detalle

de los hilos. Además de que permite construir aplicaciones paralelas portables entre

diferentes plataformas [2, 3, 4, 8]. El mecanismo de OpenMp funciona básicamente a

través de directivas de compilación más que en el uso de funciones, de forma que la

implementación del paralelismo se realiza de la forma lo más transparente posible para el

código del programa.

Las directivas OpenMP se aplican sobre un bloque estructurado, es decir, un enunciado

simple o compuesto que tenga un solo punto de entrada y un solo punto de salida (sin

saltos hacia dentro o fuera del bloque) [3].

La secuencia típica para crear una construcción OpenMP es:

Definir un bloque estructurado, el cual será ejecutado por múltiples hilos en

paralelo. En OpenMP, este bloque es llamado “región paralela”.

Distribuir la ejecución de la región paralela entre múltiples hilos

Sincronizar el trabajo de los hilos paralelos durante la ejecución de la región

paralela.

30

Controlar el ambiente de datos.

Cuando un hilo entra en una región paralela, se crea un conjunto de hilos. El hilo original

se convierte en el hilo maestro del conjunto y tiene como identificador el numero 0, y

todos los hilos incluyendo al hilo maestro ejecutan la región en paralelo. Al final el hilo

maestro recoge los resultados y éste continúa con la ejecución.

3.5 Niveles de Paralelismo:

En OpenMP, las dos principales formas para asignación de trabajo en hilos son:

Niveles de ciclos paralelos.

Regiones paralelas.

Los ciclos individuales son paralelizados con cada uno de los hilos empezando

una única asignación para el índice del ciclo. A éstos se le llama paralelismo de

fina granulación.

Con respecto a las regiones paralelas, cualquier sección del código puede ser

paralelizado no precisamente por ciclos. Esto es algunas veces llamado

paralelismo de gruesa granulación. El trabajo es distribuido explícitamente en

cada uno de los hilos usando el único identificador (myid) para cada hilo. Esto

frecuentemente se hace por el uso de declaración de if por ejemplo:

if (myid == 0)

donde myid es identificador de cada thread.

Para especificar el número de hilos se puede utilizar la clausula num_threads en la

directiva parallel, o bien se puede usar la función omp_set_num_threads. Ejemplo:

31

omp_get_thread_num(); regresa el número del hilo dentro del conjunto de hilos que está

ejecutando la función. La variable thrd_num es privada para cada hilo del grupo, al que

se le pueden anidar unas dentro de los bloques de otras. Por omisión, las construcciones

parallel no se anidan, esto se puede cambiar con la función omp_set_nested o con la

variable de retorno OMP_NESTED.

Las construcciones de compartición de trabajo distribuyen la ejecución del enunciado

asociado entre el número de hilos que encuentran, pero no lanzan nuevos hilos. Tampoco

existe una barrera implícita sobre la entrada de la construcción.

Ejemplo para el ciclo for:

Donde:

var operador_logico rb es una variable entera que no debe ser modificada dentro

del cuerpo del enunciado for.

Región a ser

paralelizada.

Int a[5][5];

Omp_set_num_threads(5);

#pragma omp parallel

{

Int thrd_num=omp_get_thread_num();

Zero_init(a[thrd_num], 5);

}

#pragma omp for lista_de_clausulas:

for (var=1b; var operador_ lógico rb; expresión_incremento)

32

expresión_incremento: puede ser uno de ++var, --var, var++, var--,

var+=incremento, var=var-incremento.

lb, rb, incremento son enteros invariantes dentro del ciclo operador_lógico puede

ser >,<, >=,<=.

La clausula schedule de la forma:

Schedule(tipo[ , tamaño_de_trozo]). Especifica cómo son divididas las iteraciones entre

los hilos del grupo.

Si tipo es static, las iteraciones son divididas en trozos del tamaño especificado por

tamaño_de_trozo, y son asignados de acuerdo al número del hilo. Si no, se especifica

tamaño_de_trozo, las iteraciones son divididas en trozo aproximadamente iguales, con

un trozo asignado a cada hilo. Si tipo es dynamic, las iteraciones son divididas en series

de trozos, cada una conteniendo tamaño_de_trozo iteraciones. Cada trozo es asignado a

un hilo que esté esperando por una asignación. Cuando no se especifica tamaño_de_trozo

por omisión es 1.

Si tipo es guided, las iteraciones son asignadas a hilos en trozos con tamaños

decrecientes. Cuando un hilo termina su trozo de iteración asignado, se le asigna

dinámicamente otro trozo, hasta que no quede ningún trozo.

Si tipo es runtime, los tamaños de los trozos se especifican en tiempo de ejecución, esto

se establece con la variable de entorno OMP_SCHEDULE.

Existe una barrera implícita al final de la construcción para el ciclo for, a menos que la

clausula nowait sea especificada.

3.6 Directivas y construcciones de sincronización.

En adición a las barreras de sincronización implicadas a algunas construcciones esta la

directiva barrier.

33

#pragma omp barrier

Se puede declarar explícitamente para sincronizar todos los hilos en un proceso. Cuando

esta directiva se encuentra, cada hilo espera hasta que todos los otros hayan alcanzado

este punto.

Para declarar una sección crítica se emplea la siguiente directiva:

#pragma omp critical [(name)]

Bloque estructurado

A restringir la ejecución del bloque estructurado asociado a un simple ciclo a la vez. Un

hilo espera al comienzo de la sección crítica hasta que ningún otro hilo esté ejecutando

una región crítica.

Estas son algunas de las directivas más utilizadas en OpenMP. Existen otras cuya

referencia se pueden ver en [10]

3.7 MPI

MPI (“Message Passing Interface”, Interfaz de Paso de Mensajes) es un estándar para la

comunicación entre procesos que define la sintáxis y la semántica de las funciones

contenidas en una librería de paso de mensajes, diseñada para ser usada en programas que

exploten la existencia de múltiples procesadores. Su principal característica es que no

precisa de memoria compartida, por lo que es muy importante en la programación para

sistemas distribuidos.

Los elementos principales que intervienen en el paso de mensajes son: el proceso que

envía, el proceso que recibe y el mensaje. Dependiendo de si el proceso que envía espera

a que el mensaje sea recibido, se puede hablar de pase de mensajes síncrono o asíncrono.

En el paso de mensajes asíncrono, el proceso emisor no espera a que el mensaje sea

recibido, y continúa su ejecución, siendo posible que vuelva a generar un nuevo mensaje

y a enviarlo antes de que se haya recibido el anterior. Por este motivo se suelen emplear

buzones, en los que se almacenan los mensajes a espera de que un proceso los reciba.

34

Generalmente empleando este sistema, el proceso emisor sólo se bloquea o para cuando

finaliza su ejecución, o si el buzón está lleno.

En el paso de mensajes síncrono, el proceso que envía espera a que un proceso lo reciba

para continuar su ejecución.

La Interfaz de Paso de Mensajes es un protocolo de comunicación entre computadoras.

Es el estándar para la comunicación entre los nodos que ejecutan un programa en un

sistema de memoria distribuida. Las implementaciones en MPI consisten en un conjunto

de bibliotecas de rutinas que pueden ser utilizadas en programas escritos en los lenguajes

de programación como son: C, C++, Fortran y Ada. La ventaja de MPI sobre otras

bibliotecas de paso de mensajes es que los programas que utilizan la biblioteca son

portables [7,13].

Con MPI el número de procesos requeridos se asigna antes de la ejecución del programa,

y no se crean procesos adicionales mientras la aplicación se ejecuta. MPI le asigna a cada

proceso una variable que se denomina rank (identificador del proceso dentro del

comunicador en el rango de 0 a p-1, donde p es el número total de procesos). El control

de la ejecución del programa se realiza mediante la variable rank, que permite determinar

qué proceso ejecuta determinada porción de código.

En MPI se define un comunicador como una colección de procesos que pueden enviarse

mensajes entre sí. El comunicador básico se denomina MPI_COMM_WORLD. MPI

también permite definir subgrupos de comunicadores a partir del comunicador básico,

teniendo por tanto cada proceso un identificador único dentro de cada grupo [13].

3.8 Llamadas utilizadas para inicializar, administrar y

finalizar comunicaciones.

MPI dispone de 4 funciones primordiales que se utilizan en todo programa con MPI.

Estas son:

1. MPI _Init. Esta función debe ser utilizada antes de llamar a cualquier otra

función de MPI y solo debe ser llamada una sola vez.

35

Int MPI_Init(int *argc, char ***argv)

2. MPI_Comm_size. Permite determinar el número total de procesos que

pertenecen a un comunicador.

Int MPI_Comm_size(MPI_Comm comunicador, int* numprocs)

3. MPI_Comm_rank permite determinar el identificador (rank) de proceso actual.

Su sintaxis es:

Int MPI_Comm_rank(MPI_Comm comunicador, int* identificador)

4. MPI_Comm_Finalize. Esta función termina una sesión MPI. Debe ser la última

llamada a MPI que un programa realice. Permite liberar la memoria usada por

MPI.

Int MPI_Init(int *argc, char ***argv)

3.9 Llamadas utilizadas para transferir datos entre dos

procesos:

La transferencia de datos entre dos procesos se consigue mediante las llamadas:

MPI_Send permite enviar información desde un proceso a otro.

MPI_Recv permite recibir información desde otro proceso.

Estas llamadas devuelven un código que indica su éxito o fracaso, y ambas funciones son

bloqueantes, es decir que el proceso que realiza la llamada se bloquea hasta que la

operación de comunicación se complete.

En MPI un mensaje está conformado por el cuerpo del mensaje, el cual contiene los datos

a ser enviados, y su envoltura, que indica el proceso fuente y el destino. El cuerpo del

mensaje en MPI se conforma por tres piezas de información: buffer, tipo de dato y count.

36

El buffer es la localidad de memoria donde se encuentran los datos de salida o

donde se almacenan los datos de entrada.

El tipo de dato, indica el tipo de dato a ser enviado en el mensaje.

El count es el número de copias del dato a ser enviado.

La envoltura de un mensaje en MPI típicamente contiene la dirección destino, la

dirección de la fuente y cualquier otra información que se necesite para transmitir y

entregar el mensaje. La envoltura de un mensaje en MPI consta de cuatro partes:

1. La fuente, identifica al proceso transmisor.

2. El destino, identifica al proceso receptor.

3. El comunicador. El comunicador especifica el grupo de procesos a los cuales

pertenecen la fuente y el destino.

4. Una etiqueta (tag), permite clasificar el mensaje. El campo etiqueta es un entero

definido por el usuario y se utiliza para distinguir los mensajes que recibe un

proceso [13].

3.10 Llamadas utilizadas para transferir datos entre varios procesos.

MPI posee llamadas para comunicaciones grupales que incluyen operaciones tipo

difusión (broadcast), recolección (gather), distribución (scatter) y reducción. A

continuación presentamos algunas funciones empleadas en nuestra aplicación:

MPI_Barrier permite realizar operaciones de sincronización. Este tipo de función suele

emplearse para dar por finalizada una etapa del programa, asegurándose de que todos los

procesos han terminado antes de dar comienzo a la siguiente instrucción.

MPI_Bcast permite a un proceso enviar una copia de sus datos a otros procesos dentro de

un grupo definido por un comunicador.

MPI_Scatter establece una operación de distribución, en la cual un dato se distribuye en

diferentes procesos.

37

Cualquier programa paralelo con MPI puede implementarse con tan solo 6 funciones,

todas ellas empiezan con MPI_ y obligan a que todos los programas escritos en MPI

contengan la directiva:

#include “mpi.h”

Este archivo contiene las definiciones, macros y prototipos de función necesarios para

compilar los programas escritos en MPI.

MPI suministra dos tipos de operaciones de comunicación:

Una operación punto a punto. Esta operación involucra a dos procesos, uno de

los cuales envía un mensaje y el otro recibe el mensaje.

Una operación colectiva. Involucra un grupo de procesos. Los grupos definen el

alcance de las operaciones de comunicación colectivas.

La fuente y el destino de un mensaje se identifican mediante el rango dentro del grupo.

Para comunicación colectiva, el emisor especifica el conjunto de procesos que participan

en la operación. Luego, el emisor restringe el acceso y proporciona un direccionamiento

independiente de la máquina a través de los rangos. No obstante, MPI permite definir

otros grupos y dentro de cada grupo cada proceso tiene un identificador (un número

entero) único, permitiendo que un proceso pueda pertenecer simultáneamente a varios

grupos y tener un identificador distinto en cada uno de ellos [14]. Esto es con el fin de

evitar comunicación extra y solo los procesos que tengan más relación se encuentren en

un mismo grupo. Esto se hace partiendo del comunicador universal mediante la siguiente

función.

int MPI_Comm_split (MPI_comm comm, int color, int key, MPI_Comm *newcom);

MPI_Comm_split(MPI_COMM_WORLD, color, myid, &comMaTrab);

MPI_COMM_WORD es un entero y es el identificador universal del grupo.

38

La palabra clave color divide los procesos y newcom es el nombre del nuevo grupo que

se creará. Cada proceso tiene un identificador único dentro de cada grupo.

VENTAJAS Y DESVENTAJAS

3.11 VENTAJAS:

Las librerías OpenMp proporcionan una forma rápida y eficiente de dar soporte a la

programación multihilos sin tener que considerar los detalles internos del funcionamiento

de los hilos en determinado Sistema Operativo. Esto permite al programador enfocarse en

el diseño sin tener que ocuparse de la implementación a detalle de los hilos. Además de

que permite construir aplicaciones paralelas portables entre diferentes plataformas.

Un programa multihilos se puede correr de manera concurrente en sistemas con un solo

procesador.

Un programa secuencial se puede convertir a versión multihilos. Solo se necesita

identificar la región a paralelizar e insertar directivas de compilador en lugares

apropiados, teniendo en cuenta la dependencia de datos, y con ello evitar deadlocks.

Las librerías de MPI se encargan de hacer el intercambio de la información de manera

transparente, por lo que el usuario solo se enfoca en el desarrollo lógico del mensaje.

Existe una implementación de dominio público llamada MPICH [27,29].

3.12 DESVENTAJAS:

Donde OpenMP tiene una ventaja es en la facilidad de la programación y la portabilidad

de los programas seriales, aunque los sistemas de memoria-compartida en general tienen

una pobre escalabilidad. Agregando procesadores adicionales a un esquema de memoria-

compartida incrementa el tráfico en el bus del sistema, haciendo más lento el tiempo de

acceso a memoria y demorando la ejecución de un programa. Un esquema de memoria-

distribuida, sin embargo, tiene la ventaja de que cada procesador está separado con su

propio bus de acceso a la memoria. Por ésta causa, son mucho más escalables. En

39

adición, es posible construir más grandes y baratos clúster usando las comodidades del

sistema conectado vía red de trabajo. Por otra parte, si un circuito dentro de un sistema de

memoria compartida falla, es posible la caída del sistema, por el contrario, si esto ocurre

en un sistema de memoria distribuida, el sistema puede continuar aun con los

procesadores disponibles, ya que solo afectara a un solo nodo.

Debido a la compartición de variables, es necesario utilizar secciones críticas, deteniendo

de alguna manera la ejecución de otros hilos que requieran accesar a algún recurso

protegido por la sección crítica. , ya que solo uno podrá estar dentro de esta.

En Sistemas distribuidos debido a la ausencia de memoria compartida, los mecanismos

de comunicación y sincronización entre los procesos es a través de la red, por lo que se

puede llevar a consumir mayor tiempo en dichos mecanismos que en procedimientos de

cálculo propios del problema.

3.13 RESUMEN DE CAPÍTULO:

En este capítulo se describen las arquitecturas del hardware y software para llevar a cabo

cómputo paralelo en arquitectura multicore y su integración a una red de computadoras

(clúster de computadoras), creando en esta forma una plataforma de multiprocesamiento

híbrida basada en dos importantes modelos de memoria compartida y distribuida. En este

esquema se tienen recursos de software compartidos entre los diferentes procesos. Para

la implementación de estas dos arquitecturas se propone el uso de dos interfaces de

programación que permiten realizar de manera transparente la programación en paralelo.

OpenMP y MPI.

OpenMP en sistemas multicore para la ejecución de un proceso de manera más

rápida.

MPI para distribuir la carga entre los diferentes procesos y procesadores

participantes en la aplicación.

En el capítulo 4 se plantea la arquitectura de software que realiza división de los procesos

que entrenan la red neuronal, en un proceso administrador y n-1 procesos trabajadores.

Esto se plantea con el fin de que solo exista comunicación entre los procesos que realizan

40

entrenamiento (procesos trabajadores) y que tengan que comunicarse datos. Sin embargo,

para llevar a cabo este modelo de programación en paralelo, es necesario emplear

mecanismos tales como: sincronización en el acceso a los recursos compartidos y la

forma en que se comunican los diferentes procesos

41

CAPÍTULO 4 CASO DE ESTUDIO.

4.1 INTRODUCCIÓN AL CAPÍTULO.

En este capítulo se describe detalladamente las etapas de la red neuronal que es el caso de

estudio. Se describen tres casos diferentes: En el primer caso se describe el

multiprocesamiento en ambas arquitecturas, se realiza la implementación de la interfaz

MPI y los pragmas de OpenMP obteniendo una ejecución hibrida de ambas. Como

segundo caso se aborda el paralelismo sólo en sistemas multicore. Debido a la

transparencia en la utilización de los pragmas propios de OpenMP, solo es necesario

identificar la región a paralelizar en el que no debe existir dependencia de datos. Por

último, como tercer caso se hace la implementación de manera serial.

En cada uno de los casos se toma tiempo de ejecución, esto para determinar la

conveniencia del procesamiento paralelo.

4.2 DESCRIPCIÓN DE LA RED NEURONAL ART2A.

ART2A es una red neuronal de entrenamiento no supervisado, cuya estructura consiste de

dos redes neuronales ART [16]. Su objetivo de es la detección, localización y

clasificación de defectos y fallas internas. La información proporcionada a la red para su

entrenamiento es a través de una base de datos que contiene información suficiente de

cada tipo de defecto. La forma de entrenamiento es comparar las entradas presentes con

categorías aprendidas seleccionadas. Las categorías aprendidas se encuentran

almacenadas en una estructura multidimensional (matriz) [15]. Su entrenamiento se

basa en 3 fases:

1. La fase de pre-procesamiento.

2. La fase de búsqueda.

3. La fase de adaptación.

42

1. La fase de pre-procesamiento es la creación de un vector de entrada I. El

vector de entrada I contiene información del fenómeno a ser estudiado A,

bajo la siguiente ecuación:

I= . . . . . . . .Ec. 4.1

El vector resultante I es el vector normalizado.

Los prototipos iniciales o categorías en W, los parámetros como el valor de

vigilancia (ρ), aprendizaje (β) y elegido (α).

Los prototipos de W pueden ser inicializados con valores aleatorios o constantes

en el rango de [0,1]. El parámetro de vigilancia ρ es el grado mínimo de similitud

entre el vector de entrada I, y cualquier categoría definida en que pertenece a

W.

El grado de aprendizaje β afecta que tan rápido el algoritmo realiza los cambios.

Este es elegido para evitar que las categorías se muevan demasiado rápido y

por tanto desestabilizando el proceso de aprendizaje.

El parámetro de elección α є [0, ∞] define la máxima profundidad de búsqueda

para un adecuado agrupamiento suministrando un desborde de punto flotante.

1. La fase de búsqueda, es una fase iterativa que puede ser dividida dentro de dos

procesos:

A. La elección.

B. La comparación.

43

A. La elección. Una vez que el vector de entrada I es calculado, este se debe

comparar con los prototipos ya definidos en W. Este proceso está encargado de

encontrar la categoría óptima, definida como la categoría similar para I respecto

a la conjunción difusa.

I= { , }. . . . .Ec. 4.2

El valor máximo de la conjunción difusa corresponde a una alta actividad de red

Tj (número de vectores aprendidos en W), donde J es la posición del vector

ganador dentro de W.

B. El proceso de comparación. Si el grado de similitud entre la entrada y cualquier

categoría es mayor o igual a ρ, entonces el prototipo j, es elegido para representar

el grupo que contiene la entrada, se dice que la red alcanza resonancia. Si el

grado de similitud es ρ, entonces otra categoría debe ser

seleccionada y comparada con el vector I. Si cualquier prototipo o categoría no

alcanza el grado de similitud, entonces el vector I debe ser agregado a W como

un nuevo prototipo.

2. La adaptación es la última fase en el algoritmo, donde el prototipo ganador tiene

que ser actualizado con respecto al patrón de entrada por:

= β( ) + (1 - β) Ec.4.3

El siguiente diagrama de flujo representa el entrenamiento de la red neuronal ART2A.

44

Figura 4.1 Algoritmo general de la red ART

CASOS DE ESTUDIO

El caso de estudio es el entrenamiento de la red neuronal descrita. El entrenamiento es

realizado en un sistema multiprocesador. El objetivo es estudiar el comportamiento de los

sistemas multiprocesador cuando se tiene un recurso compartido.

Para realizar el entrenamiento, se hace uso de varias técnicas MPI para realizar la

comunicación entre procesos y haciendo uso del software de Intel “OpenMP” para

I, W, ρ, β, α

T(j)=

j=N

red

j = j + 1

T(J)=max{T(j): j=1, . . . . N}

Y=

W =[W,I] Y(J) =0 = β(I* )+(1-β)

45

manjar hilos dentro de cada proceso. La paralelización se lleva a cabo dentro de un ciclo

para manejar los hilos en cada proceso y así acelerar la operación matricial. El número

de hilos empleados en la aplicación se maneja de acuerdo al número de procesadores en

la máquina. En este caso particular, cada máquina tiene 2 procesadores (núcleos) y

creamos 2 hilos, con el fin de que cada hilo se ejecute en un núcleo diferente y evitar

consumo de tiempo en intercambio de contexto [4,6]. Para obtener datos correctos se

hace la sincronización de los hilos. Al final de una región paralela hay una

sincronización implícita manejada de manera transparente por OpenMP. Solo al hilo

maestro (0) se le permite continuar con la ejecución.

El procedimiento para tratar el problema de entrenamiento de redes ART2A se detalla en

las secciones siguientes:

4.3 Caso 1: “IMPLEMENTACIÓN HÍBRIDA”

Se cuenta con un clúster de computadoras con arquitectura multicore. Para la

programación empleamos un paradigma de programación híbrido MPI y OpenMP,

usando MPI para conectar las máquinas dentro del grupo para formar una máquina

virtual con mayor capacidad de procesamiento. Por otra parte, utilizamos OpenMp para

explotar el paralelismo proporcionado por la arquitectura de memoria compartida.

Como se ha mencionado anteriormente, el entrenamiento de la red neuronal está diseñado

para N procesos. En la práctica se realizó en dos máquinas con características multicore

conectadas a través de una red LAN, teniendo un total de 4 procesadores para la

ejecución del problema (dos por máquina). Debido al análisis realizado en el que se

determinó que existe dependencia de datos, compartición de recursos y una necesaria

comunicación entre los procesos, la resolución de problema se diseñó de la siguiente

manera:

Los procesos se dividen en: proceso administrador o consumidor (proceso 0) y en

procesos trabajadores o productores (n-1 procesos).

46

I. El proceso consumidor (0), se encarga de recoger datos de los n-1 procesos

productores. Este proceso no realiza tareas de cálculo matricial, solamente

realiza tareas de sincronización, evaluación y envío de ordenes hacia los

demás procesos que se derivan de la ponderación de los resultados

recolectados. El proceso 0 contiene un buffer de recolección de datos

correspondientes a la evaluación de la multiplicación de los vectores de

entrada por la matriz de pesos en los procesos trabajadores. Cada proceso

trabajador envía su resultado parcial al proceso 0, el cual se encarga de

obtener un resultado global para el cada iteración del proceso ART2A.

El proceso 0 controla las comparaciones de los resultados parciales con las

siguientes variables globales

a. Una variable llamada RO que es el valor de vigilancia dentro de la red.

b. Una variable llamada ALFA que es la porción de aprendizaje de la red.

1. Al iniciar la aplicación, todos los procesos trabajadores tienen la matriz de

pesos de la red neuronal en memoria en un estado inicial “un solo vector” (fig.

4.2). Los procesos trabajadores son los que se encargan de realizar cálculos de

entrenamiento de la ART2A.

Esta matriz es el recurso compartido que está formada por vectores con categorías

aprendidas y es de tamaño MxN. Este recurso será modificado por los procesos

trabajadores, dependiendo de resultados administrados por el proceso 0. Cada renglón en

W es un vector de pesos (entrenado) de dimensionalidad N. M es el máximo número de

vectores que puede contener la matriz, j son los vectores actuales aprendidos en W. El

límite de M está definido con anticipación, aún cuando sus últimos renglones se

encuentren vacios durante la mayor parte del proceso.

47

Posición 0

1

2

3

4

Fig. 4.2 W= Matriz de pesos de la red neuronal ART2A

(Recurso compartido)

Cada computadora en el grupo tiene una base de datos (BD) que contiene información

suficiente de las características de los defectos y fallas a cerca del fenómeno a ser

estudiado. Los diferentes procesos existentes en una misma computadora comparten la

misma BD y cada uno trabaja con un vector diferente de entrada de manera paralela.

En la figura 4.3 podemos observar la división de los procesos para realizar el

entrenamiento de la ART2A. Los procesos trabajadores que comparten W y se encargan

de realizar cálculos de entrenamiento de la red se encuentran agrupados en un

comunicador exclusivo. Esto es con el fin de evitar comunicación extra con procesos que

no tengan nada que ver con proceso de entrenamiento. Una vez realizado operaciones

correspondientes de entrenamiento en cada uno de los procesos trabajadores envían datos

al proceso 0 (esto de acuerdo a los pasos 1-4). El proceso 0 solo se encarga de administrar

datos recibidos de los procesos trabajadores. A su vez es el encargado de determinar si el

vector ganador se incorpora o se actualiza, esto es dependiendo del resultado de la

comparación con el valor de vigilancia RO (se explica a continuación).

1 2 3 . . . N

2

3

.

j

.

.

M MN Máximo límite

de vectores

Vectores actuales

vector

48

El proceso de entrenamiento se detalla en los siguientes puntos.

1. Cada proceso trabajador toma datos de la BD en un vector llamado U de

dimensión N.

2. Una vez que se obtiene U[N], éste se normaliza en base a la norma Euclidiana

(Ec. 1), Los resultados obtenidos son almacenados en un nuevo vector llamado I

de dimensión N. Cada proceso trabajador realiza este paso.

Ec. 4.4

3. Continuando con el entrenamiento de la red neuronal, cada componente del

vector I multiplica a cada uno de los elementos de cada vector de W haciendo

una suma acumulada de estos productos y almacenando resultados en un nuevo

vector v que será de dimensión igual al número de renglones actuales en la matriz

W (j). El vector v queda entonces definido por la siguiente ecuación:

Proc. administrador recibe

resultados parciales obtenidos

de proc trabajadores.

Comunicación

entre procesos trabajadores

Problema

(Entrenamiento

de la red

neuronal)

Proceso 0

Proceso 1

Proceso n

Proceso 2

Comunicador entre procesos

trabajadores

Particionamiento

Comunicación

Distribución

Fig 4.3 Paralelización de la red ART2A ART2A

49

Ec. 4.5

4. Cada proceso trabajador tiene ahora un nuevo vector v[j]. En este vector se

realiza una comparación entre cada uno de los elementos que los conforman para

obtener el máximo valor junto con su posición y enviarlos al proceso

administrador (proceso 0) que está en espera de datos. Esto lo hace cada proceso

trabajador.

5. El proceso 0 que está en espera de información de los procesos productores,

establece un intervalo de tiempo para recibir información, por lo que solo

alcanzarán a pasar X número de datos de los n-1 procesos, y los X datos son

almacenando en dos vectores de tamaño X, un vector para almacenar valores y

otro para almacenar la posición correspondiente, como se muestra en la figura

4.4.

Posición 0

1

2

. .

.

X

Fig. 4.4 Vectores de dimensionalidad X con valores mayores y posición correspondiente.

6. El proceso 0 ahora tiene dos vectores. Uno con los valores mayores de cada

proceso y otro con su posición correspondiente. Ya recibidos los datos, éste

proceso se da a la tarea de comparar cada uno de los valores recibidos entre ellos

para obtener un nuevo valor mayor (general) con su posición correspondiente,

obteniendo un vector I ganador. Para determinar el grado de similitud del vector

ganador I con cualquiera de las categorías aprendidas en W, este es nuevamente

comparado con un valor llamado RO (Ec 3).

Max. Val proc1

Max. Val proc 2

Max. val proc. x

Posición proc 1

Posicion proc. 2

Posición proc x

50

>= RO Ec. 4.6

7. Si la comparación resulta verdadero, entonces, se envía la orden a todos los

procesos trabajadores de incrementar el número de vectores (j+1) para incorporar

el nuevo vector I ganador a W. Este vector ganador se envía a través de mensajes

al comunicador formado por los procesos trabajadores para que todos actualicen

la matriz y exista consistencia de datos. Para esto se utiliza una barrera de

sincronización. La barrera de sincronización elimina las condiciones de

competencia que pudieran existir entre los múltiples procesos, pues cada uno de

ellos detendrá su ejecución hasta que todos los procesos alcancen el punto de

ejecución en el que está indicada la barrera. La figura 4.4 muestra la forma en

que los procesos coordinan sus entradas a la sección crítica.

8. En caso de no cumplir con la Ec 4.6, el proceso 0 deberá difundir hacia todos los

procesos trabajadores la posición del vector I en la matriz sobre la cual se

realizará la actualización en base a la Ec 4.7 esto lo hará cada proceso

trabajador. De igual manera existe una barrera de sincronización para bloquear a

los procesos y no se les permite continuar hasta que todos los procesos tengan la

matriz actualizada.

1I Ec. 4.7

9. Cuando un proceso trabajador logre incorporar o actualizar (punto 7 u 8) regresa

a la lectura de otro vector de la BD y ejecuta los pasos a partir de la

normalización del vector, esto se repite mientras no exista fin de archivo.

La estructura de la implementación del multiprocesamiento con el esquema anteriormente

descrito puede representarse mediante el siguiente diagrama de tiempo (fig. 4.5), que

indica el estado de cada uno de los procesos durante las etapas de sincronización,

ejecución de código y comunicación. El diagrama muestra un ciclo completo de

51

sincronización y este se repite a lo largo de la ejecución de todo el programa mientras no

exista fin de archivo de la base de datos.

DESCRIPCIÓN DEL DIAGRAMA.

En este diagrama de la fig. 4.5 se muestran tres procesos durante un ciclo de ejecución

del entrenamiento de la red neuronal descrita anteriormente. La división de los procesos

se realizó de acuerdo a la descripción en la sección 4.2. Cuando se inicia la ejecución del

programa, el proceso administrador (maestro), pasa inmediatamente a la etapa de espera

de resultados que le serán enviados de los procesos trabajadores (procesos 1 y 2). Nótese

que este proceso maestro solamente realiza tareas de coordinación para el resto de los

procesos. Los procesos 1 y 2 que se encuentran en la etapa de ejecución, realizando

Tiempo

Despierta proc. 0

Envia valor mayor

Evaluación

Despiertan procs.

trabajadores

Broadcast ganador

Calcula W*I Actualiza o

Incorpora

ejecutando

en espera

Proceso 2

Proceso 0

Proceso 1

Fig. 4.5 Un ciclo completo de entrenamiento de la red ART2A en paralelo

52

cálculos relacionados al entrenamiento de la red neuronal ART2A, que pueden

describirse de la siguiente manera:

(1). Toman los datos a ser evaluados en un vector U[N],

(2). Cada proceso normaliza su vector de entrada con base a la norma Euclidiana

obteniendo un vector normal I[N].

(3). Cada uno de los vectores que conforman la matriz Wij es multiplicado por el

vector I[N] de cada proceso Vj= , donde j es el número de

vectores actuales en W y se obtiene un nuevo vector V[j],

(4). El vector V[j] hace una comparación de cada uno de los elementos que lo

conforman y toma el valor mayor junto con su posición.

(5). Los valores correspondientes al mayor valor y posición le son enviados al

proceso 0, (esto lo realiza cada uno de los procesos trabajadores 1 y 2) y se pasa

a la etapa de espera.

El proceso 0, que se encuentra en la etapa de espera, recibe datos y pasa a la etapa de

ejecución. Este proceso hará nuevamente una evaluación (global) de los datos recibidos

de los procesos trabajadores y toma el valor mayor junto con la posición correspondiente

(para recibir los datos el proceso 0 establece un tiempo, por lo que solo alcanzan a

entregar datos solo un x número de procesos). Una vez obtenido el valor mayor lo

compara con el valor de vigilancia RO (Ec. 3) que es el que determina el grado mínimo

de similitud del vector ganador I con vectores aprendidos en W. El proceso 0 informa a

los procesos trabajadores el resultado de comparación mediante una operación Broadcast,

que los restaura nuevamente al estado de ejecución. Con esto los procesos incrementan el

valor j para incorporar al vector I o bien lo actualizan en la matriz W. Una vez que envía

datos a procesos trabajadores, el proceso 0 pasa nuevamente a la etapa de espera y los

procesos trabajadores pasan a la etapa de ejecución, comunicándose entre ellos el vector

I ganador junto con su posición para incorporar o actualizar.

Esto da la descripción de un ciclo completo de entrenamiento de la red neuronal

ejecutándose en múltiples procesadores. La implementación realizada en código admite

un número arbitrario de procesos trabajadores. Aunque la descripción del mecanismo de

53

paralelización dada en los párrafos anteriores involucra por cuestiones de simplicidad,

solamente dos procesos trabajadores.

4.4 Caso 2: “IMPLEMENTACIÓN EN SISTEMAS MULTICORE”

Para hacer uso de la tecnología multicore, se parte de un código secuencial. Para llevar a

cabo la paralelización sólo se identificó la región óptima a ser paralelizada, tomando en

cuenta la dependencia de datos. La región ideal a paralelizar es la multiplicación del

vector normalizado I por cada uno de los elementos de los vectores que conforman W. En

este tipo de arquitecturas, la programación eficiente es mediante el uso de múltiples hilos

de manera que se pueda acelerar el procesamiento de multiplicación matricial. La

aceleración se encuentra cuando en W el número de vectores actuales aprendidos (j) es

grande, ya que como se puede observar en la fig. 4.6, I[N] multiplica a cada uno de los

vectores en W paralelamente, por lo que se puede considerar un incremento en

procesamiento de un 50%. Estos datos los analizaremos en el capítulo 5.

= = =

Fig. 4.6 Hilos en acción.

HILOS

Matriz W I I

1

2

3

N

1

2

3

N

1M 2 3 MN

1 2 3 N

1 2 3 N I*W1

I*W2

I*Wj

54

Se puede apreciar una bifurcación como la que se muestra en la fig. 4.7 donde el proceso

comienza con un hilo inicial y al encontrar la instrucción para paralelizar, este crea un

grupo de hilos esclavos para ejecutar un ciclo for dentro del proceso.

Fig. 4.7 Región paralela con hilos

Durante la etapa de ejecución se realizaron ejecuciones con múltiples hilos, mediante el

cual se determinó como caso ideal que el número de hilos empleados en la ejecución

debe ser igual al número de procesadores (núcleos) existentes. Esto es debido a que el

crear un hilo toma una cantidad finita de tiempo al procesador. Por otra parte, si se crean

varios hilos para paralelizar, hay que recordar que el sistema operativo, solo le da un

cierto tiempo de ejecución a cada hilo. Al terminar el tiempo de ejecución asignado, si el

hilo ha terminado o no, el control le es quitado para pasar al siguiente hilo en espera. Si el

hilo no ha terminado de realizar la tarea, el sistema operativo salva los registros del hilo,

para pasar al siguiente que le toque ejecutar.

El siguiente fragmento de código muestra el uso de algunas directivas de OpenMP:

El compilador al encontrar la directiva #pragma omp parallel for crea una región paralela.

La región a paralelizar debe estar entre llaves {} (que indican inicio y fin).

La directiva numproc=omp_get_num_procs(); obtiene el numero de procesadores.

Retorna en la variable entera numproc un número entero. Esta función es importante

dentro de nuestra aplicación, ya que se ha recomendado manejar hilos de acuerdo al

número de procesadores. Posteriormente la variable numproc se utiliza en otra de las

funciones para especificar el número de hilos empleados en la región paralela en la

siguiente función: omp_set_num_threads(numproc). Otra forma de especificar el número

de hilos, es poner directamente el número entero de hilos a manejar.

Hilo maestro Hilo maestro

Región paralela

55

void multiplicaWI(double **W,double *I, int m,int N, double *v)

int numproc=omp_get_num_procs();

{ int i,j;

double sumWI;

omp_set_num_threads(numproc);

#pragma omp parallel for

for(i=0; i<m; i++)

{ sumWI=0;

for(j=0; j<N; j++)

sumWI+=W[i][j]*I[j];

v[i]=sumWI;

}

}

Como se puede observar, las directivas OpenMP permiten implementar mecanismos de

paralelismo y sincronización en una forma muy transparente con respecto al código

secuencial. Cada llamada en OpenMP equivale a una secuencia de llamadas a APIs del

sistema operativo que crean, sincronizan y destruyen a los objetos necesarios para la

creación del código objeto correspondiente. Liberándonos de implementar estas tareas en

el código.

Una representación de flujo de ejecución es la figura 4.8. En la figura (a) se observa

como la ejecución de un proceso comienza con un hilo inicial. Al encontrar la directiva

#pragma omp parallel for de OpenMP automáticamente crea hilos, los cuales se

ejecutaran de manera paralela. En la fig. (b) se observa un mayor número de hilos. Si

dentro de los sistemas multicore, solo se cuenta con 2 núcleos, éstos se ejecutarán de

manera concurrente, ocurriendo intercambio de contexto, y un mayor consumo de tiempo

56

que le será tomado al procesador al crearlos. Aunque para el usuario esto se realice de

manera transparente.

Fig. 4.8 Flujo de ejecución de hilos

4.5 Caso 3: “IMPLEMENTACIÓN EN SERIE”

En este caso, se llevó a cabo la ejecución del programa de entrenamiento de la red

neuronal de manera secuencial (con los pasos descritos anterior mente). Como se

muestra en la siguiente figura. Donde K es un apuntador al inicio de la Base de Datos

(BD), Kmax es el límite en la BD.

HILO 1

HILO 3

HILO 4 HILO 1

b). Flujo de ejecución de hilos de

manera concurrente

HILO 2

HILO 1 HILO 1

a). Flujo de ejecución de hilos de

manera paralela.

HILO 2

HILO 1

57

Figura 4.9 Diagrama de flujo de la red ART2A de manera secuencial

Si

Inicio

W, BD, β, α, ρ

K:=0

¿K<Kmax?

sumWI := 0

sumWI: = sumWI+W[i,j]*I[i]

v[i]: = sumWI

I A W

2

“Normaliza U”

I =

Lee U de la BD

i:=0

¿i< j?

i++

i:=0

¿i<N?

i++

si ¿ρ >=mayor?

j = j + 1

=β(I* ) + (1-β)

K:= K +1

2

no

si

1

¿v[i] > v[i+1]? mayor:= v[i]

mayor = v[i+1]

i:=0

¿i < j?

i++

¿j = 0? mayor = v[j]

1

58

Para obtener el tiempo de ejecución se emplearon las funciones de tiempo de C. Esto es

con el fin de saber cuánto tiempo consume en su ejecución y con ello poder probar qué

tan conveniente o hasta que punto genera buenos resultados hacer uso de la programación

paralela. El programa serial ocupa menos espacio en memoria al necesitar menos

instrucciones, ya que se omite el código correspondiente a las pragmas y mecanismos de

comunicación y sincronización requeridos en las versiones paralelas. Así mismo se

observar que en cuanto crece el número de datos a procesar tales como: dimensión (N), el

número de renglones aprendidos en W (j) y el número de registros en la base de datos

(Kmax), el tiempo de ejecución es cada vez mayor.

4.6. RESUMEN DE CAPÍTULO:

Durante el desarrollo de este capítulo se presenta la implementación de las arquitecturas

para realizar cómputo paralelo (arquitectura multicore y sistemas distribuidos). Para el

uso de estas dos arquitecturas se presenta un programa híbrido mediante la

implementación de funciones y pragmas de MPI y OpenMP, en el que se emplean

mecanismos típicos de la programación paralela tales como: secciones críticas y

comunicación de datos. Es muy importante tener presente que en estas dos arquitecturas

no solo se comunican de manera diferente, sino también existen grandes diferencias

durante la programación. Por lo que es necesario conocer tanto sus características como

las limitaciones en cada una de ellas, esto con la finalidad de obtener un uso adecuado y

un mejor rendimiento de la ejecución de aplicaciones en arquitecturas paralelas con

implementación híbrida.

Para la implementación se establece un caso de estudio que permite determinar regiones

críticas en el acceso a un recurso compartido. Se emplean mecanismos de sincronización

59

y comunicación en el acceso que nos impone restricciones en tiempo necesarias que

permite visualizar potenciales condiciones de competencia entre procesos e hilos.

60

CAPÍTULO 5 MÉTRICAS Y ANÁLISIS DE RESULTADOS

5.1 INTRODUCCIÓN AL CAPITULO.

En este capítulo se analizan resultados de la ejecución del entrenamiento de la red

neuronal ART2A en multiprocesadores. Se analizan resultados de los casos descritos en

el capítulo anterior, mediante lo cual se puede apreciar el rendimiento conforme al

número de procesadores participantes en la aplicación. A través de las gráficas y análisis

de resultados de la ejecución del algoritmo en 2 máquinas con arquitectura multicore (4

procesadores) se observa un incremento en la aceleración de ejecución con respecto a su

versión secuencial. Debido a no contar con equipo con características similares es que no

se pudo obtener datos conforme al número de procesadores el cual determina que:

agregar más procesadores para la ejecución del programa no garantiza una aceleración en

tiempo de ejecución. Esto es debido a la parte secuencial del programa que solo tiene que

ser ejecutada por un solo procesador independientemente del número de procesadores

que se tenga para su ejecución (Ley de Amdahl) [11].

5.2 Aplicación de Métricas de desempeño en sistemas

multicore.

Sobre un sistema multiprocesador, un problema puede ser divido en un número arbitrario

de tareas independientes para un mejor desempeño con respecto al mismo en su versión

secuencial. Un sistema con 2 procesadores puede ejecutar 1.95 veces más rápido que un

único procesador, un sistema con 3 procesadores 2.9 veces más rápido, un sistema con 4

procesadores 3.8 veces más rápido y así sucesivamente [5]. Sin embargo la aceleración

casi siempre cae conforme el número de procesadores se incremente [22]. Esto es debido

a la creación de hilos, al intercambio de contexto, la comunicación y mecanismos de

61

sincronización que deben ser tomados en cuenta al desarrollar aplicaciones que requieran

la participación de más de 2 procesadores.

La tabla 1 muestra datos de la ejecución del programa de entrenamiento de la red

neuronal ART2A en 2 procesadores con varios hilos.

Los datos de entrenamiento son los siguientes:

N=100; BD=10000; W=100000; RO=0.4.

Donde:

N Es la dimensión del vector.

BD Número de registro en la base de datos.

W Es el máximo número de vectores que se pueden incorporar a W.

RO Es el grado mínimo de similitud entre el vector de entrada I y cualquier categoría

definida en W.

El tiempo de ejecución para el entrenamiento de la red de manera serial es: 20.32800 seg.

Este programa solo se ejecuta en un único procesador.

Para que este mismo programa sea ejecutado de manera paralela, se hace la

implementación de los pragmas de OpenMP, en el que se observa mejoras en tiempo con

respecto a la versión secuencial.

Número de hilos Tiempo seg. Tamaño W

2 12.32800 9163

3 14.73400 9163

4 12.79600 9163

62

5 13.89000 9163

6 12.85900 9163

7 13.35900 9163

8 12.87500 9163

9 13.25000 9163

10 12.93700 9163

. . .

. . .

. . .

10,000 14.06200 9163

100,000 14.10900 9163

1,000,000,000,000 20.32800 9163

Tabla 5.1 Resultados de entrenamiento de la red neuronal ART2A con varios hilos para

un valor de RO=0.4

Como se puede observar, el manejo de múltiples hilos en la ejecución de un programa

presenta mejoras en tiempo comparado con la versión secuencial. Sin embargo, llega un

punto en el que crear varios de éstos ya no es conveniente, por el contrario el incremento

en tiempo es notorio, esto es debido a los mecanismos de creación y sincronización de

hilos.

Se han realizado varias ejecuciones de este mismo programa con variaciones en las

variables antes mencionadas, pudiéndose observar que la variable RO presenta un gran

63

impacto en el recurso compartido W. Esta variable es el factor de semejanza del vector a

ser estudiado comparado con los vectores clasificados en W, por lo que se pude

determinar que a valores mayores (para RO) la red permite mayor clasificación, por el

contrario, a valores pequeños se realiza una clasificación más selectiva. Por lo que el

crecimiento de W está en función de dicha variable.

Considerando que la región a ser paralelizada es la matriz W es conveniente tener

dimensiones grandes “tanto para N como para M” para que valga la pena la creación de

hilos. El crear y sincronizar hilos le toma una cantidad finita de tiempo al procesador,

por lo que si se tiene dimensiones pequeñas en la matriz solo se hará mayor consumo en

tiempo en la creación de éstos que en el proceso de entrenamiento de la red.

La tabla 2 muestra datos de la ejecución del programa con una variación en el valor de

RO=0.1. Los demás datos con el mismo valor.

El tiempo de consumo en su ejecución secuencial es: 0.156000 seg.

Número de hilos Tiempo seg. Tamaño W

2 0.359000 61

3 0.312000 61

4 0.343000 61

5 0.390000 61

6 0.437000 61

7 0.546000 61

8 0.562000 61

9 0.625000 61

64

10 0.656000 61

. . 61

. . .

. . .

100 1.937000 61

200 1.968000 61

300 1.953000 61

400 2.015000 61

500 1.984000 61

1000 2.000000 61

2000 2.000000 61

3000 2.000000 61

. . .

. . .

. . .

10,000 1.98000 61

100,000 2.000000 61

1,000,000 2 61

65

10,000,000 2 61

100,000,000 2 61

1000,000,000 2 61

Tabla 5.2 Resultados de entrenamiento de la red neuronal ART2A con varios hilos para

un valor de RO=0.1

En estos datos se puede observar que el tiempo de ejecución de manera secuencial es

menor que el tiempo consumido en su versión paralela. Con esto se puede demostrar la

importancia que tiene la dimensión de los datos (N y M en este caso) en arquitecturas

paralelas.

Los resultados de ejecución de entrenamiento de la red neuronal haciendo uso de ambas

arquitecturas (sistemas de memoria compartida y sistemas de memoria distribuida) se

muestran a continuación:

N=100; BD=100; RO=0.1; W=100;

El tiempo en su versión secuencial es: 0.93000 seg.

Este mismo programa en la versión paralela (solo haciendo uso de la arquitectura

multicore) es: 0.7800 seg. Con un Sc=1.1923 y E=0.5961

66

Para 3 y 4 procesadores, los resultados son los siguientes:

Procesadores Tiempo

seg.

Aceleración

(Sc)

Eficiencia

(E)

RO=0.1 RO=0.4

3 0.68700 1.3537 0.5961 23 99

4 .421000 2.2090 0.5522 23 99

Tabla 5.3 Resultados de entrenamiento de la red neuronal ART2A para 3 y 4

procesadores.

Se puede observar un tiempo de ejecución mejor que la versión secuencial. Sin embargo,

al igual que el manejo de hilos el crear varios procesos para su ejecución de

entrenamiento no resulta conveniente. Esto se observa en los resultados de la siguiente

tabla (5.4). Para la ejecución con más de cuatro procesos el procesador comienza a

ejecutar cada proceso de manera concurrente, por lo que al compartir el tiempo del

procesador en cada una de las tareas y teniendo un recurso compartido no resulta

conveniente.

Para determinar el speed-up (aceleración) y la eficiencia (E) se hizo uso de la Ec. 2.1 y

2.2 respectivamente del capítulo 2 (sección 2.6), en el que se procedió a ejecutar el

algoritmo de entrenamiento de la red neuronal ART2A de manera secuencial (en un solo

procesador) y el mismo programa en su versión paralela (en 2, 3 y 4 procesadores).

Gráficamente la aceleración se representa en la siguiente figura.

67

Como se puede observar, el incremento en la aceleración es de manera lineal para 4

procesadores, obteniendo de igual manera una buena eficiencia. Pero como un programa

paralelo requiere comunicación entre procesadores, parte del tiempo de los procesos es

consumido en esta actividad, por lo que aumentar procesadores, nos lleva a valores de

eficiencia menores a 1.

Durante la prueba de entrenamiento se hicieron varias ejecuciones en el programa híbrido

en el que se fue incrementando el número de procesos (Tabla 5.4). Se puedo observar que

el tiempo de ejecución aumenta conforme aumentaba el número de procesos, esto es

debido a que los procesos se comienzan a ejecutar de manera concurrente, y debido a

que comparten un mismo recurso, esto también se ve reflejado en el tiempo que tarda un

proceso en espera del acceso a este.

Procesadores Tiempo

seg.

Aceleración

(Sc)

Eficiencia

(E)

RO=0.1 RO=0.4

3 0.68700 1.3537 0.5961 23 99

4 .421000 2.2090 0.5522 23 99

5 .47500 1.9578 .3915 23 99

6 .75600 1.2301 .2050 23 99

Fig. 5.1 Aceleración de entrenamiento de ART2A en 4 procesadores.

1 2 3 4 procesadores

1

2

4

Sc

68

7 .76900 1.2813 .1830 23 99

8 .92700 1.003 .1253 23 99

9 .94200 .9872 .1096 23 99

10 .97000 .9587 .0958 23 99

Tabla 5.4 Tiempo de ejecución para 10 procesos en 4 procesadores.

El diagrama 5.2 representa a 3 procesos en el que se da el tiempo de ejecución en cada

una de las etapas:

PRIMERA ETAPA (CALCULA W*I)

Se calcula el tiempo que tarda cada uno de los procesos trabajadores desde el momento

en que toma de la base de datos el fenómeno a ser estudiado, lo normaliza en base a la

norma Euclidiana obteniendo resultados en un segundo vector I[N]. Este vector

normalizado I multiplica a cada uno de los vectores contenidos en Wij, por lo que hace

una suma acumulada y el resultado lo almacena en un vector V cuya dimensión es igual

al número de vectores contenidos en W, este vector V[j] hace una comparación de cada

uno de sus elementos y elige el valor mayor con su respectiva posición. Cada uno de los

procesos obtiene su valor mayor y lo envía al proceso administrador.

SEGUNDA ETAPA (EVALUACIÓN):

El proceso establece un intervalo de tiempo para recibir información referente al dato

mayor y su respectiva posición de los procesos trabajadores, por lo que solo alcanza a

recibir X número de valores y los almacena en dos vectores, uno con valor y otro con su

posición correspondiente. Este proceso administrador hace una evaluación general y

obtiene un valor mayor general nuevamente con su posición correspondiente, el valor

69

ganador lo compara con el valor de RO para determinar el grado de similitud del vector

ganador con las categorías aprendidas en W, una vez determinado esto, este proceso

envía en mensaje para que los procesos trabajadores incorporen el vector ganador I a W o

se actualice I (explicado en capitulo 4).

TERCERA ETAPA (ACTUALIZA O INCORPORA)

En esta etapa, los procesos trabajadores que están agrupados en un comunicador exclusivo se comunican el vector ganador I ya sea para incorporar o actualizar, esto fue

determinado por el proceso de comparación (segunda etapa).

Cada uno de estos tiempos está representado en el siguiente diagrama.

Tiempo consumido por el proceso 1 en las etapas de: multiplicación 0.249000 seg.

Actualización 1.236000 seg.

Dando un tiempo total de ejecución para el proceso 1 de: 1.485000 seg

5.2 Tiempos de ciclo de ejecución del entrenamiento de la ART2A

Despierta proc. 0

Envía valor mayor

Evaluación

Despiertan procs.

trabajadores

Broadcast ganador

Calcula W*I

m Actualiza o

Incorpora

Ejecutand

o

en espera

Proceso 2

Proceso 0

Proceso 1

70

Tiempo consumido por el proceso 2 en las etapas de: multiplicación 0.232000 seg.

Actualización 1.252000 seg.

Dando un tiempo total de ejecución para el proceso 2 de: 1.484000 seg

El tiempo total de los procesos es: 1.485000 seg + 1.484000 seg = 2.969 seg.

El tiempo consumido por el proceso 0 en la etapa de evaluación es: 2.078000 seg.

El tiempo consumido en comunicación entre procesadores es: 53 nanoseg.

Por tanto, el tiempo total consumido para la ejecución del programa es:

Tiempo Total = Tiempo Secuencial + Tiempo Paralelo

Tiempo Total = 2.078000seg + 2.969 seg = 5.047seg

5.3 RESUMEN DE CAPÍTULO

En este capítulo se analizaron los resultados de ejecución del entrenamiento de la red

neuronal en 1,2,3 Y 4 procesadores obteniendo resultados alentadores en la arquitectura

híbrida y la ejecución en plataforma multicore con respecto al tiempo de ejecución en su

versión secuencial,. Además de obtener el tiempo de ejecución en cada una de las etapas.

Por lo que se puede concluir que el programa en su versión paralela obtiene buenos

resultados debido a la división de los procesos para que no exista comunicación extra. Sin

embargo se observa que conforme se aumenta el número de procesos, la comunicación y

sincronización aumenta el tiempo de ejecución, por lo que es importante a la hora de

programar tener en cuenta la división y participación de los procesadores en los procesos

participantes.

71

Además en este capítulo se pudo observar que el desempeño de la red neuronal es bueno,

ya que durante la etapa de ejecución se pudo observar que la red se encuentra

aprendiendo, es decir, que realiza la clasificación de acuerdo a resultados de

comparación del valor de similitud por lo que determina si incorpora o actualiza. Para la

variable RO (ρ), se manejaron 2 valores en el que se pudo observar que conforme al valor

sea más pequeño, este realiza una clasificación más selectiva, por lo que los renglones

(vectores) aprendidos en W incrementaran de acuerdo a esta variable. En cuanto al

desempeño del entrenamiento de la red neuronal encontramos que el parámetro de

aprendizaje Beta (β) fuee el que determinaba, como era de esperarse, la velocidad del

crecimiento de la matriz de pesos W durante las iteraciones del programa, mientras que la

selectividad se encuentra gobernada por los valores de RO, por lo que consideramos que

el esquema de paralelización aquí propuesto constituye una implementación correcta del

algoritmo ART2A.

72

CAPÍTULO 6 CONCLUSIONES.

El desarrollo de este trabajo se realizó en el estudio de los sistemas multicore en conjunto

con los sistemas de alto rendimiento (Sistemas Distribuidos). Se llevó a cabo la

implementación de ambas arquitecturas paralelas en el que se realizó un programa

híbrido haciendo uso de las interfaces de programación en este tipo de arquitecturas MPI

y OpenMP. La herramienta utilizada para hacer trabajar las máquinas como un clúster es

MPI y se emplea OpenMP para agilizar la solución del proceso en cada uno de los cores

existentes en cada máquina. Para realizar los experimentos de desempeño se utilizaron

dos máquinas conectadas entre sí a través de una interface de red del tipo LAN a una

velocidad de 100 Mbps, cada máquina está equipada con un procesador Intel Core 2 Duo

que es capaz de ejecutar múltiples hilos paralelos mediante el uso de dos núcleos, la

plataforma del sistema operativo utilizado es Windows XP de 32 bits.

Con la finalidad de analizar el comportamiento de múltiples procesadores en la ejecución

de una misma aplicación, se tomó como caso de estudio el entrenamiento de la red

neuronal ART2A en el que se tiene un recurso compartido por los diferentes

procesadores participantes en la aplicación, el cual permite determinar regiones críticas

en el acceso al dicho recurso que impone las restricciones en tiempo necesarias y permite

visualizar potenciales condiciones de competencia. Una de las ventajas en este tipo de

arquitecturas el contar con herramientas como MPI y OpenMP que permiten manejar de

manera transparente estos mecanismos, por lo que solo hay que preocuparse de la

implementación adecuada de las directivas para llevar a cabo una buena distribución de

las aplicaciones y con ello determinar el mejor algoritmo paralelo en que el tiempo

consumido sea en cálculos de proceso y no en comunicación y mecanismos de

sincronización en el que los procesos puedan estar inactivos por mucho tiempo.

Durante la ejecución del algoritmo de entrenamiento de la red neuronal se observaron

resultados óptimos en tiempo con respecto a su versión secuencial, el programa se

73

ejecutó en cuatro procesadores, debido a no contar con más equipo con características

similares es que no se pudo obtener resultados que demuestren el punto en el cual

agregar más procesadores no resulta conveniente, esto es debido a la parte secuencial del

programa propuesto por la Ley de Amdahl. Por otra parte, para mostrar que el tener

múltiples procesos activos en la ejecución de un programa tampoco es garantía en cuanto

a tiempo de ejecución en el problema, esto se determinó en base a resultados obtenidos a

través de múltiples ejecuciones del programa con diferentes números de procesos,

observándose que conforme aumenta el número de procesos incrementa también el

tiempo de ejecución, esto es debido al tiempo de comunicación que consumen procesos

para intercambiar resultados, así como también el tiempo que esperan los procesos para

accesar al recurso compartido debido a las barreras de sincronización para evitar

inconsistencia de datos.

En cuanto a la aplicación del algoritmo solo en sistemas multicore se pudo observar que

el tiempo de ejecución disminuye casi a un 50%, y con ello obteniendo un grado de

eficiencia de un 90% , por lo que se recomienda ampliamente el uso de estos sistemas y

teniendo en mente que el crear hilos así como el intercambio de contexto le toma una

cierta cantidad de tiempo al procesador, por lo que a la hora de programar se recomienda

ampliamente se utilicen hilos conforme al número de procesadores disponibles en la

máquina y asegurar una ejecución paralela.

Por tanto, dados los resultados obtenidos se recomienda ampliamente el uso de la

tecnología híbrida en sistemas de control, siempre y cuando se tenga en cuenta el rango

de valores para el cual se aprovecha el paralelismo introducido en el modelo presentado.

Un vector cuya dimensionalidad es grande (N) es conveniente para la utilización de la

plataforma paralela, además de ser altamente confiable, ya que los sistemas de

clasificación suelen trabajar con una gran cantidad de características en los patrones, y

tales características suelen ser de una dimensionalidad alta por lo que en total se maneja

un número N de variables grandes.

74

APÉNDICE.

CÓDIGO HÍBRIDO UTILIZANDO LAS INTERFACES DE PROGRAMACIÓN MPI Y

OpenMP

//Librerias utilizadas por el programa

#include <stdlib.h>

#include <stdio.h>

#include <time.h>

#include <math.h>

#include "mpi.h"

#include <omp.h>

#include <dos.h>

//Variables globales reconocidas por todas las funciones

const int N=1000; //dimension de los vectores con que se trabaja

const int mMax=1000; //máximo de vectores que se pueden incorporar a la matriz W

const double RO=0.1; //parámetro de vigilancia, es el grado mínimo de similitud

//entre el vector de entrada I y cualquier

//categoría definida en W

const double ALFA=0.3;

int numproc=omp_get_num_procs(); //Es un pragma de OpenMP que obtiene el número de

procesadores en la PC

const long kMax=1000; //número de registros que por ahora tomamos como máximo

en la base de datos

int procMax=300; //Procesos máximos que pueden manejarse

//Prototipos de las funciones utilizadas

void leerU(double * u,int N, int j);

75

void normalizaU(double * I,double * U,int N);

void muestradatos(double * U,int N);

void inicia_matriz(double**, int n, int *m);

void multiplicaWI(double **W,double *I, int m,int N, double *v);

double mayor(double *v, int M, int *pos);

void incorporaW(double **W, double *I, int *m, int N);

void actualizaW(double **W, double *I,int N,int j);

//Funcion principal

void main(int argc, char *argv[])

{

//variables para toma de mediciones de tiempos de procesamiento y comunicacion

time_t hra1,hra2;

hra1=time(NULL);

clock_t inicio_cpu = clock();

int namelen,myid, numprocs; //variables para MPI

char processor_name[MPI_MAX_PROCESSOR_NAME];

MPI_Init(&argc,&argv); //inicia el ambiente de MPI

MPI_Comm_size(MPI_COMM_WORLD,&numprocs); //Comunicador universal en MPI

con el núm. de procesos

MPI_Comm_rank(MPI_COMM_WORLD,&myid); //Identificador del proceso.

MPI_Get_processor_name(processor_name,&namelen);

printf("Algoritmo ART2a consumidor 0 dirige a procesos trabajadores \n");

if (numprocs<2 || numprocs>procMax){

printf("Se necesita al menos 2 procesos en este esquema de paralelizacion\n");

printf("el limite máximo son %d procesos\n",procMax);

printf("Programa Terminado. Adios!!!\n");

MPI_Abort(MPI_COMM_WORLD, 1);

}

76

MPI_Comm comMaTrab; //comunicador dividido en procs master y trabajadores

int color; //color para dividir los procesos

//divide el comunicador. (Si el identificador) id=0 para

master, id>0 para trabajadores,

if (myid>0) color=1; else color=0;

MPI_Comm_split(MPI_COMM_WORLD, color, myid, &comMaTrab); //Se crea un

comunicador para dividir al proceso //maestro (administrador)

de los procesos trabajadores.

MPI_Status status; //estado de recepción de comunicación

int i; //variable para ciclos

int pos=0; //posición del mayor valor del vector resultante de la

//multiplicación W[i]*I en los procesos trabajadores

int k=0; //k es el número de registro de la base de datos

//en una base de datos verdadera k puede omitirse y

un ciclo while(!eof)

double *u; //apuntador al inicio del vector leído en la BD

double *v; //apuntador al inicio del vector resultante de W[i]*I

double **W; //Apuntador al inicio de apuntadores al inicio de los

vectores

//Indica el inicio de los datos correspondientes a la

matriz de pesos

int m=0; //m es el número de renglones ocupados en la matriz

W

double *I; //Apuntador al inicio del vector Normalizado

int ganador; //id del proceso ganador en cada iteración del

procedimiento

clock_t inicio_evaluacion;

clock_t inicio_multiplicacion;

clock_t inicio_actualizacion;

clock_t evalcont=0;

77

clock_t multcont=0;

clock_t actcont=0;

W=new double*[mMax];

inicia_matriz(W,N, &m);

if (myid==0){

//SOY EL PROCESO CONSUMIDOR QUE RECOGE DATOS DE LOS PROCESOS

PRODUCTORES 1 Y 2

int *Posiciones; //buffers para recibir las posiciones y

double *Valores; //valores de los mayores resultados de WI=V

Valores=new double[procMax];

Posiciones= new int[procMax];

//printf("Soy Proceso Master\n");

while(k<kMax){ //después cambiar por un indicador leído de los

procesos

//printf("Espero Recibir\n");

//Recibir los mayores valores y posiciones de cada proceso

for (i=0;i<(numprocs-1);i++){

MPI_Recv((void *)(Valores+i),1,MPI_DOUBLE,i+1,0,

//El proceso 0 recibe valores de los

//procesos trabajadores.

MPI_COMM_WORLD,&status);

MPI_Recv((void *)(Posiciones+i),1,MPI_INT,i+1,0, // El proceso 0 recibe posicion de //los valores

MPI_COMM_WORLD,&status);

}

//printf("Ya Recibi\n");

// {printf("Valores a evaluar en el proceso 0:");

78

// muestradatos(Valores,numprocs-1);

// }

/*empieza a medir el tiempo de evaluación*/

inicio_evaluacion = clock();

if (RO>=mayor(Valores,numprocs,&ganador)){

//posición a actualizar, si es igual que el 'm' de los procesos

//trabajadores, entonces se incorpora un nuevo vector

Posiciones[ganador]=m;

//aumenta el valor de m para indicar que habrá un nuevo

renglón

m++;

}

// {

// printf("Índice ganador %i:",ganador);

// }

//envía la posición del vector a modificar del proceso ganador

//el id del proceso ganador es = ganador + 1

//++ganador;

for (i=0;i<(numprocs-1);i++){

MPI_Send((void *)&Posiciones[ganador],1,MPI_INT,i+1,

0,MPI_COMM_WORLD);

MPI_Send((void *)&ganador,1,MPI_INT,i+1,

0,MPI_COMM_WORLD);

}

k++;

/*termina de medir el tiempo de evaluación*/

evalcont+= clock()-inicio_evaluacion;

// if(k%100==0)printf("Llevo %i iteraciones \n",k);

}

79

}else {

// SOY ALGUNO DE LOS PROCESOS PRODUCTORES

v=new double[mMax];

u=new double[N];

I=new double[N];

double val;

//Inicia la semilla rand con valores distintos en cada proceso

srand((unsigned int)myid);

//printf("\nSoy un proceso trabajador\n");

while(k<kMax){ //después cambiar por while(!eof)

/*empieza a medir el tiempo de multiplicación*/

inicio_multiplicacion = clock();

leerU(u,N,k);

// printf("U:");muestradatos(u,N);

normalizaU(I,u,N);

//#pragma omp critical

// {sleep(myid); printf("I:");muestradatos(I,N);}

multiplicaWI(W,I,m,N,v);

// {printf("V=W*I en el proceso

%i:",myid);muestradatos(v,m);}

val=mayor(v,m,&pos);

//envía el valor y la posición donde se encontró el mayor valor

MPI_Send((void

*)&val,1,MPI_DOUBLE,0,0,MPI_COMM_WORLD);

MPI_Send((void *)&pos,1,MPI_INT,0,0,MPI_COMM_WORLD);

/*Termina de medir el tiempo de multiplicación*/

80

multcont+= clock()-inicio_multiplicacion;

/*Empieza a medir el tiempo de actualización*/

inicio_actualizacion = clock();

//recibe el id del proceso ganador y la posición a modificar

MPI_Recv((void *)&pos,1,MPI_INT,0,MPI_ANY_TAG,

MPI_COMM_WORLD,&status);

MPI_Recv((void *)&ganador,1,MPI_INT,0,MPI_ANY_TAG,

MPI_COMM_WORLD,&status);

//este punto es una barrera de sincronización para todos los

//procesos trabajadores.

MPI_Bcast((void *)I,N,MPI_DOUBLE,0,comMaTrab);

//Hasta aquí todos tienen el mismo vector I del proceso ganador

if (pos==m){

//Todos incorporan a I en su copia de W

incorporaW(W,I,&m,N);

}else{

//Todos actualizan la posición pos en us copia de W

actualizaW(W,I,N,pos);

}

//printf("\nun trabajo hecho\n");

k++; //para la siguiente iteración

/*Termina de medir el tiempo de actualización*/

actcont+= clock()-inicio_actualizacion;

}

}

MPI_Barrier(comMaTrab);

81

//muestranos la matriz W

if (myid==1){

// printf("\nW empieza en la dirección %p:\n",W);

// printf("\nValor de m %d:\n",m);

printf("\nDatos de la matriz W:\n");

for (i=0;i<m;i++)

muestradatos(W[i],N);

}

if (myid == 0){

hra2=time(NULL);

clock_t fin_cpu = clock();

printf("\nTiempo %f segundos\n",difftime(hra2,hra1));

printf("\nTiempo de cpu %f segundos\n",

((double)(fin_cpu - inicio_cpu))/CLOCKS_PER_SEC);

printf("\n número de renglones de la matriz %i\n",m);

}

/*Tiempos de slots en el ciclo*/

if (myid == 0){

printf("\nTiempo evaluación %f segundos\n",

((double)evalcont)

/CLOCKS_PER_SEC);

}

for (i=1;i<numprocs;i++){

if (myid==i){

printf("\nProc %i Tiempo multiplicación %f segundos\n",

i,((double)multcont)

/CLOCKS_PER_SEC);

printf("\nProc %i Tiempo actualización %f segundos\n",

i,((double)actcont)

/CLOCKS_PER_SEC);

82

}

}

MPI_Finalize();

}

void leerU(double * u,int N, int j){

//estos serian los valores que se leen de la base de datos aquí iría el código

//para leer la base de datos por ahora se rellenan aleatoriamente con números entre -100 y

100

for (int i=0; i<N; i++){

u[i]=-100+200*rand()/RAND_MAX;

}

//aquí los valores de la base de datos se

//tendrían referenciados por el apuntador u

}

void normalizaU(double *I,double * u,int N){

double sumatoria=0;

double norma;

int i;

for (i=0; i<N; i++){

sumatoria+=u[i]*u[i];

}

norma=sqrt(sumatoria);

if (norma>0.0) //evitar divisiones por cero

for (i=0; i<N; i++){

I[i]=u[i]/norma;

}

}

83

void muestradatos(double * U,int N)

{

printf("[");

for (int i=0; i<N; i++)

printf("%5.2f, ", U[i]);

printf("]\n");

}

void inicia_matriz(double** W, int N, int *m)

{

int j=0;

double *I=new double[N];

W[0]=new double[N];

//llena el primer renglon de W con datos

//aleatorios entre -1 y +1

for (j=0; j<N; j++){

W[0][j]=-1+2*rand()/(double)RAND_MAX;

}

//normaliza el primer renglon de W para

//que se cumpla la condicion de ||w||

normalizaU(I,W[0],N);

for(j=0; j<N; j++){

W[0][j]=I[j];

}

(*m)++;

delete [] I;

}

void multiplicaWI(double **W,double *I, int m,int N, double *v)

{

int i,j;

double sumWI;

omp_set_num_procs(numproc);

84

#pragma omp parallel for

for(i=0; i<m; i++)

{

sumWI=0;

for(j=0; j<N; j++)

sumWI+=W[i][j]*I[j];

v[i]=sumWI;

}

}

double mayor(double *v, int m, int *pos)

{

double mayor;

mayor=v[0];

*pos=0;

for (int j=0; j<m;j++)

{

if (v[j]>mayor){

mayor=v[j];

*pos=j;

}

}

return mayor;

}

void incorporaW(double **W,double *I, int *m,int N)

{

W[*m]=new double[N];

for (int j=0;j<N;j++)

W[*m][j]=I[j];

(*m)++;

}

void actualizaW(double **W, double *I,int N,int pos)

{

85

int k;

for (k=0;k<N;k++){

W[pos][k]=ALFA*W[pos][k]+(1-ALFA)*I[k];

}

}

CODIGO SERIAL Y/O PARALELO.

Este mismo código lo utilizamos en ambos casos, como se ha mencionado solo se le agregan las

directivas de OpenMp al código secuencial, además del archivo de cabecera <omp.h>.

#include <math.h>

#include <time.h>

#include <stdlib.h>

#include <iostream.h>

#include <stdio.h>

#include <omp.h>

const int N=1000;

const int mMax=1000; //máximo número de vectores de peso

const double RO=0.1;

const double ALFA=0.3;

const long kMax=1000;

int numproc=omp_get_num_procs();

void leerU(double * u,int N, int j);

void normalizaU(double * I,double * U,int N);

void muestradatos(double * U,int N);

void inicia_matriz(double**, int n, int *m);

void multiplicaWI(double **W,double *I, int m,int N, double *v);

double maximo(double *v, int m,int *j);

void incorporaW(double **W, double *I, int *m, int N);

#include <omp.h>

86

void actualizaW(double **W, double *I,int N,int j);

int main(){

time_t hra1,hra2;

hra1=time(NULL);

clock_t inicio_cpu = clock();

double u[N]; //vector con los datos leidos de la BD

double I[N]; //vector nomalizado

double *W[mMax]; //matriz de los vectores de pesos acumulados

double *w; //vector de pesos

double *v=new double[mMax];

double valor;

int m=0; //cantidad de vectores de pesos al momento

int k=0; //contador del numero de registro en la BD

int j=0; //contador de vector de peso que se

//esta analizando actualmente en la matriz W

int i=0; //contador de elementos por vector

srand(1);

inicia_matriz(W,N,&m);

while (k<kMax){ //ciclo principal de iteracion

leerU(u,N,k);

//printf("U:");muestradatos(u,N);

normalizaU(I,u,N);

//multiplica W por I para obtener v

multiplicaWI(W,I,m,N,v);

//printf("U:");muestradatos(u,N);

87

valor=maximo(v,m,&j);

// printf("valor mayor= %f",valor);

if (RO>=valor){

//incorpora I a W

incorporaW(W,I,&m,N);

}

else{

//actualiza w[j]

actualizaW(W,I,N,j);

}

k++;

} //termina ciclo principal de iteracion

printf("\nDatos de la matriz W:\n");

for (i=0; i<m; i++)

muestradatos(W[i],N);

hra2=time(NULL);

printf("\nTiempo %i segundos\n", (long)difftime(hra2,hra1));

clock_t fin_cpu = clock();

printf("\nTiempo %f segundos\n", difftime(hra2,hra1));

printf("\nTiempo de cpu %f segundos\n",((double)(fin_cpu -

inicio_cpu))/CLOCKS_PER_SEC);

printf("\nnumero de renglones de la matriz %i\n",m);

printf("\n numero de procesadores en mi CPU %d \n", numproc);

return 0;

}

void leerU(double * u,int N, int j){

//estos serian los valores que se leen

//de la base de datos aqui iria el codigo

//para leer la base de datos

//por ahora se rellenan aleatoriamente

88

//con numeros entre -100 y 100

for (int i=0; i<N; i++){

u[i]=-100+200*rand()/RAND_MAX;

}

//aqui los valores de la base de datos se

//tendrian referenciados por el apuntador u

}

void normalizaU(double *I,double * u,int N){

double sumatoria=0;

double norma;

int i;

for (i=0; i<N; i++){

sumatoria+=u[i]*u[i];

}

norma=sqrt(sumatoria);

if (norma>0.0) //evitar divisiones por cero

for (i=0; i<N; i++){

I[i]=u[i]/norma;

}

}

void muestradatos(double * U,int N)

{

printf("[");

for (int i=0; i<N; i++)

printf("%5.2f, ", U[i]);

printf("]\n");

}

void inicia_matriz(double** W, int N, int *m)

{

89

int j=0;

double *I=new double[N];

W[0]=new double[N];

//llena el primer renglon de W con datos

//aleatorios entre -1 y +1

for (j=0; j<N; j++){

W[0][j]=-1+2*rand()/(double)RAND_MAX;

}

//normaliza el primer renglon de W para

//que se cumpla la condicion de ||w||

normalizaU(I,W[0],N);

for(j=0; j<N; j++){

W[0][j]=I[j];

}

(*m)++;

delete [] I;

}

void multiplicaWI(double **W,double *I, int m,int N, double *v)

{

int i,j;

double sumWI;

for(i=0; i<m; i++)

{

sumWI=0;

for(j=0; j<N; j++)

sumWI+=W[i][j]*I[j];

Omp_set_num_threads(numproc)

#pragma omp parallel for

90

v[i]=sumWI;

}

}

double maximo(double *v, int m, int *j)

{

double dato1, mayor;

int i;

if (m==1){

mayor=v[0];

*j=0;

}

else if (m >1){

i=0;

mayor=v[i];

while(i<m){

dato1=v[i];

//dato2=v[i+1];

if (dato1>mayor){

mayor=dato1;

*j=i;

}

i=i+1;

}

}

else if (m<0)

printf("No hay datos");

return mayor;

}

double mayor(double *v, int m, int *pos)

{

91

double mayor;

mayor=v[0];

*pos=0;

for (int j=0; j<m;j++)

{

if (v[j]>mayor){

mayor=v[j];

*pos=j;

}

}

return mayor;

}

void incorporaW(double **W, double *I, int *m,int N){

W[*m]=new double[N];

for (int j=0; j<N;j++)

W[*m][j]=I[j];

(*m)++;

}

void actualizaW(double **W, double *I,int N,int pos)

{

int k;

for (k=0;k<N;k++){

W[pos][k]=ALFA*W[pos][k]+(1-ALFA)*I[k];

}

}

92

REFERENCIAS BIBLIOGRAFICAS:

[1] Strouptrup Bjarne, “The C++ Programming Language”. 2nd

edition,

Addison Wesley, 1991.

[2] Chandra Rohit, Dagum Leonardo. “Parallel Programming in

OpenMP”,MORGAN KAUFMANN PUBLISHERS, 2001.

[3 ] Lastovetsky Alexey L., “Parallel Computing on Heterogeneous Networks”.

University College, Dubln Ireland, WILEY-INTERSCIENCE, 2003.

[4] Norton Scott J., Dipasquale Mark D., “The Multithreaded Programming

Guide”. Thread Time. PRENTICE HALL PTR, 1997.

[5] Lewis Bil, Berg Daniel J., “A Guide to Multithreaded Programing”.

Threads Primer. PRENTICE HALL, 1996.

[6] Beveridge Jim and Wiener Robert, “Multithreading Applications in

Win32” The complete Guide to Threads. Addison-Wesley, 2001.

[7] J. Quinn Michael, “Parallel Programming in C with MPI and OpenMP”,

Mc Graw-Hill, 2003.

93

[8] Intel Corporation. “Intel Core 2 Duo Processor on 45-nm Proccess

Datasheet. Intel Corporation www.intel.com, 2008.

[9] Intel Corporation. “Intel VTune Performance Analyzer Documentation”.

www.intel.com, 2008.

[10] www.openmp.org

[11] Dong Hyuk Woo and Hsien-|Hsin S. Lee, “Extending Amdahl’s Law for

Energy-Efficent Computing in the Many-Core Era”, Published by the IEEE

Computer Society, December 2008.

[12] Dan Quilan, Markus Schordan, Qin Yi, and Bronis R. de Supinski. A C++

Infrastructure for Automatic Introduction and Translation of OpenMP

Directives. WOWPAT, Berlin Heidelberg, 2003 .

[13] Ref. dirección de mpi.org.

[14] www.mpi.org (página official de MPI).

[15] Moisen, M.C. Benítez-Pérez, H. Medina L. Ultrasonic (XXXX) NDT for

flaws characterisation using ARTMAP network and wavelet analysis. Int. J.

Materials and Product Technology.

[16] Carpenter, G.A., Grossberg, S., Markuzon, N., Reynolds, J.H. and Rosen,

D.B. (1992). Fuzzy ARTMAP. A neural network architecture for

94

incremental supervised learning of analog multidimensional maps, IEE

Trans. Neural Network, Vol. 3, pp. 698 713.

[17] Frank, T., Kraiss, K.F. and Kuhlen, T. (1998) Comparative analysis of fuzzy

ART and ART-2A network clustering performance, IEEE Trans. Neural

Network, vol. 9, pp. 544 559.

[18] Carretero Pérez Jesús, Anasagasti Pedro de Miguel, Sistemas operativos,

una visión aplicada, Mc Graw Hill, 2001

[19] M. Morris Mano, Arquitectura de computadoras, Prentice Hall, 2001

[20] Von Neumann Architecture. Página Web.

http://www.hostgold.com.br/hospedagem-sites/o_que_e/vonNeumann+architecture/+.

[21] Tanenbaum. S. Andrew, Distributed Operating Systems, Prentice Hall 1996

[22] Bruce P. Lester, The Art of Parallel programming, Prentice Hall, 1993.

[23] Alan H. Karp and Horace P. Flatt, Measuring Parallel Processor

Performance, may 1990 vol 33 num 5.

[24] Butenhof R. David, Programming with POSIX Threads, ADDISON-

WESLEY PROFESSIONAL COMPUTING SERIES, May 2000

[25] Lamport Leslie, Specifying Systems, Addison-Wesley Professional, 2002

[26] Rohit Chandra-Dagum Leonardo, Parallel Programming in OpenMP,

MORGAN KAUFMANN PUBLISHERS, 2001.

95

[27] http://www-unix.mcs.anl.gov/mpi/mpich/.

[28] ftp://ftp.mcs.anl.gov/pub/mpi/mpich.tar.gz.

[29] www.mcs.anl.gov/mpi/mpich1

[30] Gail A. Carpenter and Stephen Grossberg, Pattern Recognition by Self-

Organizing Neuronal Networks. 1991.

[31] CARPENTER and Stephen GROSSBERG, NEURONAL NETWORKS

FOR VISION AND IMAGE PROCESSING, 1992, Edited by Gail A.