Este documento presenta un algoritmo paralelo para contar el número de pelotas de diferentes colores en una alberca para niños de manera más rápida. Se divide la tarea de generar números aleatorios y contar pelotas entre tres hilos para ejecutar las tareas en paralelo. Luego se suman los resultados parciales para determinar el color más frecuente. El algoritmo se implementa en Java y los resultados muestran que el enfoque paralelo es más rápido que hacer el conteo de forma secuencial, especialmente a medida que aumenta

1. Algoritmo
Paralelo
Equipo:
Ana Rivera 1494080
Melissa Treviño 1497325
Ilse Martínez 1488075
Clemente Villareal 1486246

2. Objetivo
 modelar un problema que puede ser
resuelto en un periodo de tiempo más
corto mediante el uso de un sistema en
paralelo.

3. Problema
 En una alberca de pelotas
para niños hay 3 colores de
pelotas amarillo, azul y verde
cada una con el número 1, 2,
y 3 pintado en ellas
respectivamente. Se tienen
aproximadamente 3000
pelotas y se desea saber el
número de pelotas de cada
color para determinar que
tipo de pelota es la más
abundante.

4.  Entradas: 3000 datos numéricos entre 1 y
3.
 Salidas: Color de pelota más frecuente.

5. Proceso
 Se divide la tarea de generar números
aleatorios del 1 al 3 entre 3 hilos de
ejecución para que después cada hilo
pueda realizar un conteo parcial de los
diferentes tipos de número. Al finalizar la
clase principal sumará los conteos
parciales y se compararán esos conteos
para determinar la pelota que con mayor
frecuencia se presentó.

6. Pseudocódigo
1. Inicio
2. Declarar variables (
(am=0,az=0,ver=0 , am2=0,az2=0,ver2=0,
am3=0,az3=0,ver3=0 ): enteros
(color, color2, color3): enteros
(i=1): entero
(sumam=0, sumaz=0, sumver=0) : enteros

7. 3. Iniciar hilo1
Ciclo for ( Mientras i <= 1000)
Valor aleatorio para color [1,3]
If (color ==1) -> am++
If (color ==2) -> az++
If (color ==3) -> ver++
4. Iniciar hilo2
Ciclo for ( Mientras i <= 1000)
Valor aleatorio para color2 [1,3]
If (color2 ==1) -> am2++
If (color2 ==2) -> az2++
If (color2 ==3) -> ver2++

8. 5. Iniciar hilo3
Ciclo for ( Mientras i < =1000)
Valor aleatorio para color3[1,3]
If (color3 ==1) -> am3++
If (color3 ==2) -> az3++
If (color 3==3) -> ver3++
6. Fin (hilo1, hlo2, hilo3)
7. sumam = am + am2 + am3;
8. sumaz = az + az2 + az3;
9. sumver=ver + ver2 + ver3;

9. 10. Condición (si sumam > sumaz&&
sumam>sumver)
11. Se imprime Hay más amarillos
12. Condición (si sumaz > sumam && sumaz
>sumver)
13. Se imprime Hay más azules
14. Condición (si sumver> sumaz && sumver
>sumam)
15. Se imprime Hay más verdes
16. fin

12. Aplicación
del Algoritmo
Paralelo

13. Objetivo
 Implementar el algoritmo creado en la
actividad anterior en un lenguaje de
programación.

14. Introducción
 Como se explicó en la actividad anterior,
el problema se pudo resolver mediante la
aplicación de hilos de ejecución en Java.
Los hilos son usados como una
herramienta que nos permite llevar a
cabo la ejecución en paralelo de nuestro
programa ya que por medio de estos
podemos ejecutar las distintas tareas a la
vez.

15. Programa con ejecución
secuencial
 Contador de pelotas y tiempo

16.  Resultado

17. Programa con ejecución en
paralelo
 Constructor del hilo

18.  Contador de Pelotas
 Suma de Pelotas

19.  Resultado

20. Tabla comparativa
Cantidad de
pelotitas Tiempo Paralelo
Tiempo
Secuencial
3000 7 15
30000 17 46
300000 28 131
3000000 69 1068

21. Gráfica de resultados

22. Conclusiones
Efectivamente los resultados obtenidos con el
paralelo fueron más pequeños en comparación del
tiempo de ejecución del programa en secuencial.
La primera vez que probamos nuestro programa en
paralelo obtuvimos resultados contrarios a los
esperados (el tiempo en paralelo era mayor al
secuencial), lo cual pudimos solucionar al modificar
nuestro código ya que en un principio cada hilo
sacaba sus propios números aleatorios pero ahora
hay un arreglo que contiene todos estos y entonces
cada hilo lo único que hace es checar sólo partes
del mismo.