UNIVERSIDAD NACIONAL DEL SANTA

FACULTAD DE INGENIERÍA
E.P. INGENIERÍA DE SISTEMAS E INFORMÁTICA

TÓPICO I
Algoritmos Paralelos

CICLO
VII
AUTORES
Baes Vásquez Diego
Medina Charcape Andrés
Saavedra Altuna Kenny
Ramírez Cava Shanira

ASESOR
Ing. Luis Enrique Ramírez Milla

CHIMBOTE – PERÚ
2019
 ÍNDICE
I. INTRODUCCIÓN ........................................................................................................................ 3
II. JUSTIFICACIÓN ...........................................................................Error! Bookmark not defined.
III. MARCO TEORICO ................................................................................................................. 4
3.1. DEFINICIÓN DEL ALGORITMOS PARALELOS .............................................................. 4
3.2. ETAPAS DE LOS ALGORITMOS PARALELOS ................................................................ 4
3.2.1. PARTICIÓN: ................................................................................................................... 4
3.2.2. COMUNICACIÓN: .......................................................................................................... 5
3.2.3. AGRUPAMIENTO: ......................................................................................................... 6
3.2.4. ASIGNACIÓN:................................................................................................................. 7
3.3. TÉCNICAS ALGORITMICAS PARALELAS ....................................................................... 8
3.4. MODELOS DE ALGORITMOS PARALELOS .................................................................. 11
IV. CONCLUSIONES................................................................................................................... 19
V. LINKOGRAFÍA ......................................................................................................................... 20
I. INTRODUCCIÓN
La mayoría de los algoritmos actuales son secuenciales, es decir, especifican una
secuencia de pasos en los que cada paso consiste en una sola operación. Estos
algoritmos se adaptan bien a las computadoras actuales, que básicamente realizan
operaciones de forma secuencial.
Aunque la velocidad a la que operan las computadoras secuenciales ha mejorado a
una tasa exponencial durante muchos años, ahora la mejora tiene un costo cada vez
mayor. Como consecuencia, los investigadores han buscado mejoras más rentables
mediante la construcción de computadoras "paralelas": computadoras que realizan
operaciones múltiples en un solo paso.
Para resolver un problema de manera eficiente en una máquina paralela,
generalmente es necesario diseñar un algoritmo que especifique operaciones
múltiples en cada paso, es decir, un algoritmo paralelo
II. MARCO TEORICO

2.1. DEFINICIÓN DEL ALGORITMOS PARALELOS

Son métodos de resolución de problemas donde ejecuta procesos por partes en el
mismo instante de tiempo por varias unidades de procesamiento para unir las
partes y obtener un resultado correcto. El termino proceso se puede definir como
parte de un programa que se ejecuta por un procesador.
El problema se divide en un conjunto de subproblemas que pueden ser resueltos
simultáneamente por procesadores independientes.
La paralización es muy utilizada en los procesadores modernos porque es más
rápido resolver tareas de computación mediante esta técnica en comparación con
técnicas secuenciales.
Ejemplo de Paralización en la vida cotidiana: En una librería llegan un conjunto
de libros, los bibliotecarios tienen 3 días para guardar los libros. La solución basada
en paralización será que cada uno de ellos agrupe los libros por determinadas
categorías al mismo tiempo.

2.2. PRINCIPIOS DE LOS ALGORITMOS PARALELOS

El desarrollo de algoritmos es un componente crítico de la resolución de problemas
usando computadoras. Un algoritmo secuencial es esencialmente una secuencia de
pasos básicos para resolver un problema determinado usando una computadora
en serie. De manera similar, un algoritmo paralelo es una receta que nos dice cómo
resolver un problema dado usando múltiples procesadores. Sin embargo,
especificar un algoritmo paralelo implica más que solo especificar los pasos. Como
mínimo, un algoritmo paralelo tiene la dimensión adicional de concurrencia y el
diseñador del algoritmo debe especificar conjuntos de pasos que se pueden
ejecutar simultáneamente. Esto es esencial para obtener cualquier beneficio de
rendimiento del uso de una computadora paralela. En la práctica, la especificación
de un algoritmo paralelo no trivial puede incluir algunos o todos de los siguientes:
Identificar partes del trabajo que se pueden realizar al mismo tiempo.
Mapeo de los trabajos simultáneos en múltiples procesos que se ejecutan
en paralelo.
Distribuir los datos de entrada, salida e intermedios asociados con el
programa.
Gestionar accesos a datos compartidos por múltiples procesadores.
Sincronización de los procesadores en varias etapas de la ejecución del
programa paralelo.

2.3. ETAPAS DE LOS ALGORITMOS PARALELOS

2.3.1. PARTICIÓN:
Esta etapa consiste en dividir o descomponer el problema en componentes o tareas
pequeñas, que pueden ser ejecutados concurrentemente (J. Aguilar, E. Leiss, 2004).
 Para lograr una buena partición se divide tanto los cálculos asociados con el
problema
Descomposición de dominio: Conocido como paralelismo de datos, en donde
los datos son divididos en partes de aproximadamente el mismo tamaño, para
ser asignadas a diferentes procesadores, cada uno de ellos trabaja sólo con la
parte de datos que le son asignados. Por supuesto, los procesadores pueden
necesitar comunicarse para intercambiar datos. El algoritmo con paralelismo
de datos consiste en una secuencia de instrucciones aplicadas a distintos datos.
(Cerverón Vicente, sf).

Descomposición funcional: Conocido como paralelismo de tareas, consiste en

dividir el problema en un gran número de partes más pequeñas (muchas más
partes que procesadores disponibles) y las subtareas son asignadas a los
procesadores disponibles. De manera que, cuando un procesador termina una
subtarea, recibe otra subtarea hasta que queden resueltas todas.
El paralelismo de tareas se implementa sobre un paradigma de maestro y
esclavos. El proceso maestro va asignando las subtareas a los procesos
esclavos, recogiendo los resultados producidos y asignando subtareas
restantes. (Cerverón Vicente, sf).

Al particionar se deben tener en cuenta los siguientes aspectos:

 El número de tareas debe ser por lo menos un orden de magnitud superior
al número de procesadores disponibles para tener flexibilidad en las etapas
siguientes.
 Tratar que las tareas sean de tamaños equivalentes, ya que, facilita el
balanceo de la carga de los procesadores.
 El número de tareas debe ser proporcional al tamaño del problema. Así, se
podrá resolver problemas más grandes cuando se tenga más procesadores.
Es decir, que el algoritmo sea escalable. (Hoeger Herbert, sf).

2.3.2. COMUNICACIÓN:
Las tareas generadas por una partición pueden ejecutarse concurrentemente pero
no pueden, en general, ejecutarse independientemente. Los cálculos en la ejecución
de una tarea normalmente requerirán de datos asociados con otras tareas. Los
datos deben transferirse entre las tareas y así permitir que los cálculos procedan.
En la descomposición por dominio, la comunicación puede ser difícil de determinar
(hay que identificar las operaciones que requieren datos de diferentes fuentes). En
cambio, en la descomposición funcional, es fácil de determinar, ya que las
interrelaciones entre las tareas vienen dadas por las funciones que realiza cada
una, y de las cuales quizás la otra depende. (J. Aguilar, E. Leiss, 2004).
Los tipos de comunicación está categorizada de la siguiente manera:
Comunicación local y global: Cuando un número pequeño de tareas necesitan
valores de otras tareas se crean canales entre las tareas envueltas. Una tarea se
comunica solamente con sus vecinos. Esta es comunicación local. Y la
 comunicación global ocurre cuando todas o casi todas tareas necesitan valores
de las otras tareas, es decir, cada tarea se comunica con todas, o casi todas. Así,
en una comunicación global, muchas tareas pueden participar, lo que puede
conllevar a muchas comunicaciones.
Comunicación estructurada y no estructurada: En este tipo de
comunicación, el patrón de comunicación de una tarea con sus vecinos forma
una estructura regular, por ejemplo, del tipo árbol o malla. Las no estructuradas
pueden generar grafos de comunicación arbitrarios.
Comunicación estática o dinámica: La comunicación estática establece
patrones de comunicación que no cambian en el tiempo, mientras que la
dinámica puede ser solamente determinada durante el tiempo de ejecución de
la aplicación.
Comunicación síncrona o asíncrona: La comunicación síncrona implica que
las tareas se ejecutan coordinadamente (es decir, se deben sincronizar entre
ellas), y la asíncrona significa que cada tarea puede ejecutarse al obtener los
datos que requiere, sin tener que esperar por otras tareas. (J. Aguilar, E. Leiss,
2004).

La comunicación requerida por un algoritmo puede ser definida en dos fases.

Primero se definen los canales que conectan las tareas que requieren datos con las
que los poseen. Segundo se especifica la información o mensajes que deben ser
enviado y recibidos en estos canales. (Gilberto Díaz, 2010).
En la etapa de comunicación hay que tener en cuenta los siguientes aspectos:
 Todas las tareas deben efectuar aproximadamente el mismo número de
operaciones de comunicación. De lo contrario, el algoritmo no sea extensible
a problemas mayores, ya que, habrá cuellos de botella.
 La comunicación entre tareas debe ser tan pequeña como sea posible.
 Las operaciones de comunicación y los cómputos de diferentes tareas deben
poder proceder concurrentemente. (Hoeger Herbert, sf).

2.3.3. AGRUPAMIENTO:
Las tareas y las estructuras de comunicación definidas en las dos primeras etapas
del diseño son evaluadas con respecto a los requerimientos de ejecución y costos
de implementación: Si es necesario, las tareas son combinadas en tareas más
grandes para mejorar la ejecución o para reducir los costos de comunicación y
sincronización.
Reduciendo el número de mensajes, a pesar de que se envíe la misma cantidad de
información, se reduce el costo de crear un nuevo canal de comunicación. (J.
Aguilar, E. Leiss, 2004).

En la etapa de agrupación se debe tener en cuenta los siguientes aspectos:

 Verificar si la agrupación redujo los costos de comunicación.
  Si se han replicado cómputos y/o datos, se debe verificar que los beneficios
son superiores a los costos.
 Revisar si el número de tareas es extensible con el tamaño del problema.
 Si el agrupamiento ha reducido las oportunidades de ejecución concurrente,
se debe verificar que aún hay suficiente concurrencia y posiblemente
considerar diseños alternativos.
 Analizar si aún se puede reducir el número de tareas sin introducir
desbalances de cargas o reducir la extensibilidad. (Hoeger Herbert, sf).

2.3.4. ASIGNACIÓN:
En esta etapa, cada tarea es asignada a un procesador de tal modo que intente
satisfacer las metas de competencia al maximizar la utilización del procesador y
minimizar los costos de comunicación. (J. Aguilar, E. Leiss, 2004).
La asignación puede ser estática (se establece antes de la ejecución del programa)
o en tiempo de ejecución mediante algoritmos de balanceo de carga.
La asignación de tareas puede ser realizada de las siguientes maneras:
Asignación estática: Aquí, las tareas son asignadas a un procesador al
comienzo de la ejecución del algoritmo paralelo y corren ahí hasta el final.
En ciertos casos puede resultar en un tiempo de ejecución menor respecto
a asignaciones dinámicas y también puede reducir el costo de creación de
procesos, sincronización y terminación.
Asignación dinámica: Se hacen cambios en la distribución de las tareas
entre los procesadores a tiempo de ejecución, o sea, hay migración de
tareas a tiempo de ejecución. Esto es con el fin de balancear la carga del
sistema y reducir el tiempo de ejecución. Sin embargo, el costo de
balanceo puede ser significativo y por ende incrementar el tiempo de
ejecución. (Hoeger Herbert, sf).

Entre los puntos que hay que revisar en esta etapa encontramos:
 Si se han considerado algoritmos con un número estático de tareas y
algoritmos de creación dinámica de tareas.
 Si se usan algoritmos centralizados de balanceo, hay que asegurarse
de que no sea un cuello de botella.
  Evaluar los costos de las diferentes alternativas de balanceo dinámico,
en caso de que se usen, y que su costo no sea mayor que los beneficios.
(Hoeger Herbert, sf).

Ilustración 1: Etapas de los Algoritmos Paralelos

2.4. TÉCNICAS ALGORITMICAS PARALELAS

En el diseño de algoritmos paralelos existen técnicas generales que se pueden
utilizar una variedad de áreas. Algunos son variantes de técnicas secuenciales
estándar y otros son nuevos para los algoritmos paralelos

2.4.1. DIVIDE Y CONQUISTARÁS:

Un algoritmo divide y vencerás divide el problema a ser resuelto en subproblemas
que son más fáciles de resolver que el problema original, resuelve los
subproblemas, y se funde las soluciones a los subproblemas para construir una
solución al problema original.
El paradigma de dividir y conquistar mejora la modularidad del programa y, a
menudo, conduce a algoritmos simples y eficientes. Por lo tanto, ha demostrado ser
una herramienta poderosa para los diseñadores de algoritmos secuenciales.
Dividir y vencer juega un papel aún más destacado en el diseño de algoritmos
paralelos. Debido a que los subproblemas creados en el primer paso son
típicamente independientes, se pueden resolver en paralelo. A menudo, los
subproblemas se resuelven de forma recursiva y, por lo tanto, el siguiente paso de
división produce incluso más subproblemas para ser resueltos en paralelo. Como
consecuencia, incluso los algoritmos de división y conquista que fueron diseñados
 para máquinas secuenciales típicamente tienen cierto paralelismo inherente. Sin
embargo, tenga en cuenta que para poder
Dividir y conquistar para producir un algoritmo altamente paralelo, a menudo es
necesario paralelizar el paso de división y el paso de fusión. También es común en
algoritmos paralelos dividir el problema original en tantos subproblemas como sea
posible, de modo que todos puedan resolverse en paralelo.

2.4.2. ALEATORIZACION
Los números aleatorios se utilizan en algoritmos paralelos para garantizar que los
procesadores puedan tomar decisiones locales que, con alta probabilidad, se
suman a buenas decisiones globales. Aquí consideramos tres usos de la
aleatoriedad.
Muestreo: Un uso de la aleatoriedad es seleccionar una muestra
representativa de un conjunto de elementos. A menudo, un problema se
puede resolver seleccionando una muestra, resolviendo el problema en esa
muestra y luego usando la solución para la muestra para guiar la solución
para el conjunto original. Por ejemplo, supongamos que queremos ordenar
una colección de claves enteras. Esto se puede lograr dividiendo las llaves
en cubetas y luego clasificando dentro de cada cubeta. Para que esto
funcione bien, las cubetas deben representar intervalos no superpuestos de
valores enteros, y cada cubeta debe contener aproximadamente el mismo
número de llaves El muestreo aleatorio se usa para determinar los límites
de los intervalos. Primero, cada procesador selecciona una muestra
aleatoria de sus claves. A continuación, todas las claves seleccionadas se
ordenan juntas.
Finalmente, estas claves se utilizan como límites. Tal muestreo aleatorio
también se usa en muchos algoritmos de comparación de geometría
computacional, grafos y cadenas en paralelo.
La ruptura de la simetría: otro uso de la aleatoriedad es la ruptura de la
simetría. Por ejemplo, considere el problema de seleccionar un gran
conjunto independiente de vértices en un grafo en paralelo. (Un conjunto
de vértices es independiente si no hay dos vecinos.) Imagine que cada
vértice debe decidir, en paralelo con todos los demás vértices, si unirse al
conjunto o no. Por lo tanto, si un vértice elige unirse al conjunto, todos sus
vecinos deben elegir no unirse al conjunto. La elección es difícil de realizar
simultáneamente por cada vértice si la estructura local en cada vértice es
la misma, por ejemplo, si cada vértice tiene la misma cantidad de vecinos
Como resultado, el punto muerto se puede resolver mediante el uso de la
aleatoriedad para romper la simetría entre los vértices.
Equilibrio de carga: un tercer uso de la aleatoriedad es el equilibrio de
carga. Una forma de dividir rápidamente una gran cantidad de elementos
de datos en una colección de subconjuntos de tamaño aproximadamente
uniforme es asignar aleatoriamente cada elemento a un subconjunto. Esta
técnica funciona mejor cuando el tamaño promedio de un subconjunto es
al menos logarítmico en el tamaño del conjunto original.
2.4.3. TÉCNICAS DE PUNTERO PARALELAS
Muchas de las técnicas secuenciales tradicionales para manipular listas, árboles y
grafos no se traducen fácilmente en técnicas paralelas. Por ejemplo, técnicas como
atravesar los elementos de una lista vinculada, visitar los nodos de un árbol en
postorden o realizar un recorrido en profundidad de un grafo parecen ser
inherentemente secuenciales. Afortunadamente, estas técnicas a menudo pueden
ser reemplazadas por técnicas paralelas con aproximadamente el mismo poder.
Puntero saltando: Una de las más antiguas técnicas de punteros paralelos es el
puntero saltando [88]. Esta técnica se puede aplicar a listas o árboles. En cada paso
de salto del puntero, cada nodo en paralelo reemplaza su puntero con el de su
sucesor (o padre). Por ejemplo, una forma de etiquetar cada nodo de una lista n-
nodo (o árbol) con la etiqueta del último nodo (o raíz) es usar el salto del puntero.
Después de la mayoría de los pasos de ⌉ log n⌉ , cada nodo apunta al mismo nodo,
el final de la lista (o la raíz del árbol).
Recorrido de Euler: Un recorrido de Euler por un grafo dirigido es una
ruta a través del grafo en el que cada borde se atraviesa exactamente una
vez. En un grafo no dirigido, cada borde se reemplaza típicamente con dos
bordes opuestos. El recorrido por Euler de un árbol no dirigido sigue el
perímetro del árbol visitando cada borde dos veces, una vez en el camino
hacia abajo y una vez en el camino hacia arriba. Al mantener una estructura
enlazada que representa el recorrido de Euler por un árbol, es posible
calcular muchas funciones en el árbol, como el tamaño de cada subárbol.
Esta técnica usa trabajo lineal y profundidad paralela que es independiente
de la profundidad del árbol. El recorrido de Euler a menudo se puede
utilizar para reemplazar un recorrido estándar de un árbol, como un
recorrido transversal en profundidad.
Contracción del grafo: La contracción del grafo es una operación en la cual
un grafo se reduce en tamaño mientras se mantiene parte de su estructura
original. Normalmente, después de realizar una operación de contracción
del grafo, el problema se resuelve recursivamente en el grafo contratado.
La solución al problema en el grafo contratado se usa para formar la
solución final. Por ejemplo, una forma de dividir un grafo en sus
componentes conectados es primero contraer el grafo fusionando algunos
de los vértices con los vértices vecinos, luego encontrar los componentes
conectados del grafo contratado y finalmente deshacer la operación de
contracción. Muchos problemas pueden resolverse contrayendo árboles,
en cuyo caso la técnica se llama contracción de árbol.
Descomposición del oído: Una descomposición de oído de un grafo es una
partición de sus bordes en una colección ordenada de caminos. El primer
camino es un ciclo, y los otros se llaman orejas. Los puntos finales de cada
oreja están anclados en caminos anteriores. Una vez que se encuentra la
descomposición de un grafo en un oído, no es difícil determinar si dos
 bordes se encuentran en un ciclo común. Esta información puede usarse en
algoritmos para determinar biconnectividad, triconnectividad, 4-
conectividad y planaridad. Se puede encontrar una descomposición de la
oreja en paralelo usando trabajo lineal y profundidad logarítmica,
independientemente de la estructura del grafo. Por lo tanto, esta técnica se
puede utilizar para reemplazar la técnica secuencial estándar para resolver
estos problemas, búsqueda de profundidad en primer lugar.

2.4.4. OTRAS
Muchas otras técnicas han demostrado ser útiles en el diseño de algoritmos
paralelos. Encontrar separadores de grafos pequeños es útil para dividir datos
entre procesadores y reducir la comunicación. La función hash es útil para
equilibrar la carga y asignar direcciones a la memoria

2.5. MODELOS DE ALGORITMOS PARALELOS

2.5.1. MODELO DE DATA-PARALLEL
Muchos datos son tratados de una forma igual o similar
Algoritmos numéricos
Datos en arrays o vectores
- Procesamiento vectorial
- Paralelismo asignando partes distintas del array a distintos
procesadores
Memoria compartida (Paralelismo de Datos)
- Distribución del trabajo en hilos
- Paralelización automática o implícita
Memoria Distribuida (Particionado de Datos)
- Distribución de los datos a los procesos
- Técnica de particionado de datos o paralelización explícita
Ejemplo: Suma de n datos
Esquema secuencial:
s=0;
for (i=0; i<n; i++)
s=s+a[i];
endfor

Paralelización Automática:
Con opción de compilación si no hay dependencia de datos o el compilador
detecta que se puede resolver.
 Con Pragma (t(n,p)=n/p):
s=0;
#pragma omp parallel for priate(i) reduction(+:s)
for (i=0; i<n; i++)
S=s+a[i]
endfor

Distintas posibilidades de asignación de los datos a los hilos, con cláusula

Schedule: bloques contiguos, cíclica, dinámica.

2.5.2. MODELO DE GRÁFICO DE TAREAS

Ejemplo:
Multiplicación vector x matriz dispersa (sparse)
Computar:
Solo para los A[i,j] diferentes de 0. Suponer que hay n CPUs y se reparten
las filas de A y los valores de b (ej.: CPU0 es dueña de b[0])

2.5.3. MODELO DE POOL DE TAREAS

El mapeo dinámico de un loop es mucjos sub-loops
Ejemplo:
Mapeo Es el mecanismo por el que las tareas se asignan a los procesos
Un proceso: proceso como se entiende en sistemas operativos, o parte de un
proceso (hilo)
Generalmente 1 proceso ??1 CPU/ core
2.5.4. MODELO MAESTRO-ESCLAVO

Ejemplo:
Método de Montecarlo
Este algoritmo consiste en generar experimentos aleatorios independientes
consistentes en generar N puntos x, y que pertenezcan de 0 a 1 y contabilizar
C los números que caen dentro del cuadrante de un circulo de radio 1.

El área del circulo es igual a pi*radio **2, el área del cuadrante es pi/4, y la
probabilidad es C/N = pi/4 osea pi = 4C/N.

La aproximación más precisa es cuando N tiende al infinito.

Este es el algoritmo secuencial en Python:
#!/usr/bin/python
import random
import math

def enCirculo(x, y):

acierta = False
resultado = x ** 2 + y ** 2
if resultado <= 1:
acierta = True
return acierta

def pi(n):
c = 0
for i in range(n):
x = random.random()
y = random.random()
acierta = enCirculo(x, y)
if acierta:
c = c + 1
return (4.0 * c)/n

print pi(10000000)

Paralelización
Este reparto consiste en la generación de N experimentos en un conjunto de
P procesadores. Cada procesador puede generar puntos y contar cuales C
caen en el rango del círculo con 1 de radio.
Al iniciar solo el proceso principal conoce cuales son los valores de N, osea
el número de pruebas que se quiere hacer, y cuantos procesadores se van a
tener.
Después se envían a los procesos esclavos la N, para que empiecen a calcular.
 Inicialmente el proceso maestro del programa paralelo conoce los
valores de N y P.
 Paso 1: Envío de N y P a los procesos esclavos del programa paralelo
  Paso 2: Cada proceso del programa paralelo realiza el trabajo que le
corresponde. Cálculo del número de experimentos Np = N/P.
Realización de los experimentos para calcular Cp.

 Paso 3: Los procesos esclavos del programa paralelo envían el

resultado Cp que han calculado al proceso maestro
- El proceso maestro calcula el número total de aciertos C = C0+…+Cp-1
- … y a continuación calcula el valor estimado de π π = 4C/N

Y por último los procesos esclavos envían sus resultados al proceso

maestro, para que el maestro calcule el número de aciertos y lo
multiplique por 4 (por la fórmula que acabamos de ver) y lo divida entre
el total de experimentos N. El siguiente programa en python emula este
comportamiento con hilos para poder mandar cada suma al proceso
maestro, este es el programa:
#!/usr/bin/python
import threading, time
import math, random
lock = threading.Lock()
import Queue

def __init__(self, n, q):

threading.Thread.__init__(self)
self.n = n
self.x = 0
self.y = 0
self.c = 0
def enCirculo(self, x, y):
acierta = False
res = x ** 2 + y ** 2
if res <= 1:
acierta = True
return acierta
def run(self):
for i in range(self.n):
self.x = random.random()
self.y = random.random()
self.acierta = self.enCirculo(self.x, self.y)
if self.acierta:
self.c = self.c + 1
pii = (4.0 * self.c)/self.n
q.put(self.c)
q = Queue.Queue()
hilos = 5 #simula 5 procesadores
n = 100000000 #numero de pruebas
for i in range(hilos):
h = pi(n/5, q)
h.start()
h.join()
print q.qsize()
i = 0

En donde señaletotal
que =sean
0 5 procesadores, osea 5 hilos que realicen la tarea
indicada. for i in range(q.qsize()):
Y la ejecución se ve así:
num = q.get(i)
print num #aqui se imprime la suma que obtiene cada
hilo individual
total = num + total
pi = (4.0 * total)/n # formula para obtener el pi tomando
el total de aciertos y dividiendo
print "Pi en colaboracion " + str(pi)
2.5.5. MODELO DE PIPELINE O PRODUCTO-CONSUMIDOR
El problema se divide en una serie de etapas. Cada etapa se ejecuta, por
ejemplo, en un procesador, y pasa resultados a la siguiente.

Es un tipo de descomposición funcional, relacionado con la repetición del

mismo proceso sobre una serie larga de datos (p.e., en tiempo real:
procesado de vídeo).

Condiciones:
-- que se ejecute más de una vez el mismo problema.
-- que se procese una serie larga de datos.
-- que se pueda pasar datos a la siguiente fase mucho antes del final del
cálculo de cada fase.
--que el tiempo de proceso asociado a cada fase sea similar (load balancing).

Topología ideal: cadena / anillo.

Normalmente no se genera un número muy elevado de procesos.

Algunos ejemplos:
-- procesado de señal (sonido, vídeo...)
-- simulaciones de procesos segmentados (computación)

2.5.6. MODELOS HIBRIDOS

Tradicionalmente el procesamiento paralelo se ha dividido en dos grandes
modelos, el de memoria compartida y el de pasaje de mensajes.
 Memoria compartida: los datos accedidos por la aplicación se
encuentran en una memoria global accesible por los procesadores
paralelos. Esto significa que cada procesador puede buscar y
almacenar datos de cualquier posición de memoria
independientemente. Se caracteriza por la necesidad de la
sincronización para preservar la integridad de las estructuras de
datos compartidas.
 Pasaje de mensajes: los datos son vistos como asociados a un
procesador particular. De esta manera, se necesita de la
comunicación por mensajes entre ellos para acceder a un dato
 remoto. En este modelo, las primitivas de envío y recepción son las
encargadas de manejar la sincronización.
Relacionado con la aparición de la arquitectura cluster de multicore surge el
modelo de programación híbrido, en el cual se combinan las estrategias
recientemente expuestas. Esto implica una combinación de los modelos de
programación paralela memoria compartida y pasaje de mensajes.

El objetivo de utilizar el modelo híbrido es aprovechar y aplicar las

potencialidades de cada una de las estrategias que el mismo brinda, de
acuerdo a la necesidad de la aplicación. Esta es un área de investigación de
gran interés actual. Actualmente, entre los lenguajes que se utilizan para
programación híbrida aparecen OpenMP para memoria compartida y MPI
para pasaje de mensajes.

2.6. ANALISIS DE ALGORITMOS PARALELOS

En la programación paralela son necesarias herramientas que permitan estimar el
tiempo de ejecución y la memoria consumidos por el algoritmo, para determinar
si es adecuado o no para la resolución del problema, teniendo como objetivo
principal el desarrollo algoritmos eficientes
 Se realiza un estudio del algoritmo a priori para identificar si es adecuado
para el problema o para seleccionar entre un conjunto de algoritmos
 Se realiza un estudio del algoritmo a posteriori para comparar entre 2
programas según el tamaño de entrada

2.6.1. FACTORES PRINCIPALES

Lenguaje del programa
Máquina
Compilador
Tipos de datos
Usuarios

2.6.2. FACTORES QUE INFLUYEN EN EL TIEMPO DE EJECUCIÓN

Competencia por la memoria
Fracción del código
Asignación de procesos
Computación extra: variables de control, cálculos, etc.
Sincronización

2.6.3. ELEMENTOS
 Tiempo de Ejecución:
Formulas de diapo 12
 Ocupación de Memoria
 Formulas de diapo 13

 Conteo de Instrucciones
Diapos 14 y 15
 Notación Asíntota
Diapo 16
 Tiempos de comunicación
Diapos 19 y 20

2.6.4. EJEMPLO DE LA SUMA DE N NÚMEROS

Diapo 21
2.6.5. EJEMPLO DE MEMORIA COMPARTIDA DE SUMA DE N NÚMEROS
Diapo 22,23,24
2.6.6. EJEMPLO DE MEMORIA DISTRIBUIDA DE SUMA DE N NÚMEROS
Diapo 25,26,27
2.6.7. COMPARACIÓN FINAL
Diapo 28

III. CONCLUSIONES
IV. LINKOGRAFÍA

J. Aguilar, E. Leiss (2004). Introducción a la computación paralela. [PDF file]. Mérida,

Venezuela. Disponible en:
https://docs.google.com/viewer?url=http%3A%2F%2Fwww.ing.ula.ve%2F~aguilar%2Fpubl
icaciones%2Fobjetos%2Flibros%2FICP.pdf
Elver Álvarez (2016), ¿Qué son los Algoritmos Paralelos?. Disponible en:
https://prezi.com/8hsxmu4dh47j/que-son-los-algoritmos-paralelos-algoritmos-que-
pueden-s/
Cerverón Vicente (sf). Algoritmos Paralelos. [PDF file]. España. Disponible en:
https://docs.google.com/viewer?url=http%3A%2F%2Finformatica.uv.es%2Fiiguia%2FALP%
2Fmateriales%2F1_2_a_ComputacionParalela.pdf.
Hoeger Herbert (sf). Introducción a la computación paralela. [PDF file]. Mérida, Venezuela.
Disponible en:
https://docs.google.com/viewer?url=http%3A%2F%2Fwww.saber.ula.ve%2Fbitstream%2F
123456789%2F15969%2F1%2Fcom_par.pdf
Gilberto Díaz. (2010). Diseño de Algoritmos Paralelos [PDF file]. Mérida, Venezuela.
Disponible en:
https://docs.google.com/viewer?url=http%3A%2F%2Fwebdelprofesor.ula.ve%2Fing
enieria%2Fgilberto%2Fparalela%2F08_DisenoDeAlgoritmosParalelos.pdf
Ananth Grama, Anshul Gupta, George Karypis, Vipin Kumar(sf). Introduction to Parallel
Computing, Second Edition. Disponible en: http://parallelcomp.uw.hu/ch03lev1sec6.html