Practica 1 Efecto Blur Secuencial y POSIX
Angela Marı́a Muñoz Medina1 y Juan Esteban Caicedo Palacio2
Abstract— En este documento se presenta la ejecución del al-
goritmo blur, mostrando un paralelo entre una implementación
secuencial y una utilizando hilos POSIX. A continuación se
explican las implementaciones realizadas junto con el análisis
de experimentos y resultados de acuerdo a tiempos de respuesta
obtenidos.
I. INTRODUCCI ÓN
En esta primera práctica, se va a comparar el rendimiento
de dos algoritmos para la generación de un efecto borroso
de una imagen predefinida. Se aplicarán las siguientes condi-
ciones para la paralelización:
• CPU - Secuencial
• CPU - Hilos POSIX
Se probarán imágenes de diferentes resoluciones tales como
720p, 1080p y 4K. El filtro borroso con kernel será variado
entre 2 y 16 hilos.
Este filtro borroso se obtiene procesando cada valor de los
pixeles de la imagen con una función que disminuye el valor
original de cada pixel.
II. ALGORITMO IMPLEMENTADO
El algoritmo implementado para el efecto blur, se basa en
tomar el valor promedio de los pixeles que rodean al pixel
seleccionado, y su valor es modificado por el promedio, de
tal forma que el efecto borroso sea creado.
Por ejemplo, ası́ se verı́a el pixel a reemplazar: En el centro
se observa el pixel que va a ser cambiado y se le aplicará el
efecto borroso.
El procedimiento será repetido en todos los pixeles de la
imagen para que sean intercambiados y se finalice el efecto
borroso.
Para lograr completamente el efecto, fue instalada la
librerı́a ”OpenCV”, esta permite representar una imagen
como una matriz que corresponde a los canales de color RGB
(Red, Green, Blue). El efecto se aplica de acuerdo al número
de hilos usados en el procesamiento de la imagen, cada hilo
utilizado está encargado de aplicar el efecto a determinadas
filas únicamente.
III. P ROCEDIMIENTO
Para la implementación del algoritmo blur, se hizo uso
de la librerı́a OpenCV anteriormente mencionada para la
obtención de la imagen y la separación de los 3 canales de
color R, G ,B; se utiliza una matriz vacı́a del mismo tamaño
de la imagen original que almacena los valores promedio
obtenidos por el kernel mientras recorre la imagen, para
los bordes iniciales de la imagen se toma el indice como
el modulo de la imagen, simulando que es infinita. Con la
implementación de hilos, se divide el total de filas en el
número de estos para que cada hilo se encargue de la misma
cantidad de filas lo cual disminuye el tiempo de ejecución.
Al finalizar se asignan los valores obtenidos de cada canal a
cada elemento de la matriz y esta se guarda como la imagen
modificada.
Para la implementación del algoritmo en OpenMp, se
usan los hilos que el sistema operativo tiene y se calcula
el efecto Blur para cada pixel por medio de los hilos que
están disponibles en el sistema. Cada hilo procesa un pixel,
y al finalizar, toma otro hasta haber completado la matriz y
aplicado el efecto en su totalidad.
Esta imagen ilustra el funcionamiento de la paralelización
OpenMP donde la ejecución procede de izquierda a derecha.
Inicialmente, la aplicación comienza con un único hilo (hilo
maestro). Cuando en la ejecución se encuentra una región
paralela de código, el hilo maestro crea nuevos hilos parale-
los. Al finalizar los hilos la región paralela, se sincronizan y
se vuelven a un único hilo.
IV. R ESULTADOS
A continuación se muestran los resultados y tiempos del
algoritmo implementado para la paralelización secuencial y
POSIX(Hilos). Para probar el algoritmo se usaron 2,4,8 y 16
hilos, además un kernel de 5 y 15, usando un computador con • Imagen 1080px, tiempo vs hilos para cada kernel:
procesador Intel Core I7-4700MQ,este tiene 4 procesadores
fı́sicos. Hilos k=3 k=5 k=7 k=9 k=11 k=13 k=15
1 0.771 1.104 2.036 3.577 4.573 8.126 10.668
A. Secuencial 2 0.317 0.633 1.214 1.643 4.148 3.431 6.227
4 0.246 0.438 0.905 1.1 1.525 2.279 3.049
• Imagen 720px, tiempo vs kernel
8 0.238 0.439 1.071 1.138 1.646 2.58 3.839
16 0.237 0.457 1.088 1.152 1.676 3.024 3.135
Hilos k=3 k=5 k=7 k=9 k=11 k=13 k=15
1 0.251 0.48 0.901 1.472 2.047 3.945 4.259
• Imagen 1080px, tiempo vs kernel

Hilos k=3 k=5 k=7 k=9 k=11 k=13 k=15

1 0.608 1.157 2.124 3.337 4.643 8.251 12.353
• Imagen 4K, tiempo vs kernel

Hilos k=3 k=5 k=7 k=9 k=11 k=13 k=15

1 4.289 8.817 18.331 31.472 44.778 61.467 90.282

• Imagen 4K, tiempo vs hilos para cada kernel:

Hilos k=3 k=5 k=7 k=9 k=11 k=13 k=15

1 4.757 10.775 16.732 31.099 43.819 62.054 84.215
2 2.367 6.607 10.31 16.443 27.336 38.479 46.843
4 1.830 3.586 6.715 12.179 19.531 26.145 41.58
8 2.099 4.623 6.719 13.305 19.008 29.295 40.93
16 2.506 5.565 8.637 13.476 18.917 31.219 40.032

B. POSIX
• Imagen 720px, tiempo vs hilos para cada kernel:

Hilos k=3 k=5 k=7 k=9 k=11 k=13 k=15

1 0.251 0.50 0.83 1.316 1.819 2.781 3.261
2 0.168 0.303 0.478 0.701 0.986 1.954 2.403
4 0.141 0.224 0.332 0.473 0.654 1.411 1.155
8 0.128 0.203 0.311 0.458 0.631 1.366 1.278
16 0.128 0.2 0.32 0.454 0.658 0.904 1.176

• Speedup:

N. Hilos 720p 1080p 4k

2 2.005 1.561 1.758
4 2.615 2.914 2.130
8 1.733 1.959 2.257
16 1.826 1.965 2.237

Como se puede ver en los gráficos, el uso de hilos reduce

en gran manera el tiempo de procesamiento de la imagen.
C. OpenMP
• Imagen 720p, tiempo vs hilos para cada kernel:

Hilos k=3 k=5 k=7 k=9 k=11 k=13 k=15

1 0.262 0.484 0.912 1.388 2.794 4.188 5.4355
2 0.254 0.48 0.846 1.379 2.31 3.432 4.771
4 0.252 0.482 0.839 1.393 2.185 4.105 4.71
8 0.256 0.49 0.84 1.459 2.242 3.64 3.826
16 0.259 0.491 0.834 1.417 2.289 2.931 5.609

D. CUDA
• 2 Hilos:

Tamano imagen Tiempo k=5 (s) Tiempo k=15 (s)

720p 0.1260 0.1335
1080p 0.1638 0.1677
4k 0.6272 0.6818
• 4 Hilos:

Tamano imagen Tiempo k=5 (s) Tiempo k=15 (s)

• Imagen 1080p, tiempo vs hilos para cada kernel: 720p 0.1278 0.12.90
1080p 0.1645 0.1680
Hilos k=3 k=5 k=7 k=9 k=11 k=13 k=15 4k 0.6148 0.6231
1 0.628 2.107 2.264 4.634 6.615 8.955 16.608
2 0.612 2.067 2.118 3.878 6.369 8.700 15.501 • 8 Hilos:
4 0.622 1.263 2.052 3.289 5.364 8.548 14.073
8 0.618 1.134 2.073 4.262 6.252 8.612 12.513 Tamano imagen Tiempo k=5 (s) Tiempo k=15 (s)
16 0.606 1.133 2.056 4.268 5.424 8.408 11.002 720p 0.1274 0.1285
1080p 0.1658 0.1675
4k 0.6401 0.6851
• 16 Hilos:

Tamano imagen Tiempo k=5 (s) Tiempo k=15 (s)

720p 0.1267 0.1283
1080p 0.1665 0.1652
4k 0.6425 0.6820
Ejemplo funcionamiento Efecto ’Blur’.

• Imagen sin efecto (720p):

• Imagen 4K, tiempo vs hilos para cada kernel:

Hilos k=3 k=5 k=7 k=9 k=11 k=13 k=15

1 5.744 10.407 26.275 35.17 44.546 62.582 83.577
2 4.673 11.242 24.597 35.635 45.77 61.306 101.051
4 4.519 9.885 19.459 34.373 45.393 66.800 95.923
8 5.239 11.019 21.107 33.148 46.781 68.515 93.444
16 4.396 10.437 19.312 32.12 45.236 66.965 100.451 • Imagen con efecto ’Blur’:
 V. CONCLUSIONES
• Se evidencia que el uso de hilos POSIX para
implementar paralelismo mejora considerablemente el
tiempo de ejecución del algoritmo.

• Se puede observar en las gráficas que después de

utilizar cierta cantidad de hilos, no es muy notoria la
disminución de tiempo, por el contrario si se usan más
hilos que procesadores en la CPU, se puede evidenciar
un aumento de los tiempos de ejecución.

• Se reduce a casi la mitad de tiempo entre la

implementación secuencial y la implementación con
hilos, en particular para imágenes de 720p.