Moviendo partículas y binarizando imágenes


Como parte de la entrega del trabajo práctico Nº 1 de la materia HPC\@UNS era requerido hacer una página web con los resultados. Me pareció mas práctico usar mi blog... y acá estamos.

[Partículas en movimiento]{.Apple-style-span style="font-size: x-large;"}

La primera parte del TP era ir a un sitio de Berkeley y bajar el código para simular la interacción entre partículas usando un algoritmo totalmente serial, otro utilizando PThreads y otro OpenMP. Lo primero que hice fué hacer unas corridas y ver los resultados que obtenía.

Nota: cada punto del gráfico es el promedio de 5 corridas del mismo algoritmo con los mismos parámetros. -Esto es válido para todos los gráficos de éste blog post, pero en los datos usados para generar los primeros solo se encuentran los valores ya promediadios.


Respuesta en tiempo al número de partículas de cada implementación  en un servidor Sparc T2 (Niágara2) de 8 cores con 8 hilos livianos cad uno.



Respuesta en tiempo al número de partículas de cada implementación  en una máquina AMD Athlon 64 X2 Dual Core processor 5000+.


Notemos que el número de threads de OpenMP no está definido, sino que se toma el de la instalación por defecto (Debian Wheezy en ambas máquinas).

Enseguida podemos notar varias cosas:

  • Los algoritmos son O(n²). Nada raro si uno mira el código fuente, los ciclos for anidados saltan a la vista.
  • Paralelizar el algoritmo vale la pena a partir de una cierta cantidad de datos. Se podría pensar en \~256 como un buen número de threshold, aunque seguramente es dependiente del hardware y del problema/implementación del algoritmo.
  • Crear hilos tiene un costo mínimo asociado. En el caso del Sparc, el costo es mayor, aunque es notable como mejora el rendimiento con OpenMP.
[Intentemos mejorar éste desempeño.]{.Apple-style-span style="font-size: large;"} Mirando el código fuente vemos que la interacción entre partículas se calcula todas entre todas. Lo interesante es que el resultado de la interacción de una partícula p con una partícula q es la misma pero de signo contrario a la interacción de la partícula q con la partícula p. Entonces podemos hacer los cálculos una sola vez entre dos partículas cualquiera.
Por otro lado, la interacción entre partículas es basada en la distancia entre ellas. Si la distancia es cero, no hay interacción. Entonces una partícula no interactúa con si misma.
Desde el punto de vista del hardware y el paralelismo, podemos utilizar la máxima cantidad e hilos posibles para cada caso.  Definitivamente ésto va a traer acarreado mayor tiempo de ejecución en los casos de pocas partículas, pero debería ser mejor a medida que el número de partículas aumenta.
~~**Nota:** debido a que el código fuente original no estipula una licencia y por ende se debe interpretar como "todos los derechos reservados", no hago públicas las modificaciones del código.~~ **Actualización 18/11/2011:** le escribí a [Vasily Volkov](http://www.cs.berkeley.edu/~volkov/), responsable del sitio y código de Berkeley arriba linkeado, y tuvo la gentileza de reponderme diciéndome que la licencia en BSD modificada. En el [repositorio del código](http://dumbledore.com.ar/gitweb/?p=hpc/particulas.git;a=summary) incluyo el mail (en formato [mbox](http://en.wikipedia.org/wiki/Mbox)) y la licencia propiamente dicha. ¡Gracias Vasily!
Veamos entonces los resultados, empezando por el caso serial.

Comparación del algoritmo original (1.0.1) con el algoritmo modificado 1.1.6 para el caso serial.


En éste caso vemos que tanto para Cardumen (Sparc) como para Luna (AMD Athlon) los cambios generaron una reducción del tiempo de ejecución. A su vez, podemos comparar el desempeño de ambos procesadores.


Comparación del algoritmo original (1.0.1) con el algoritmo modificado 1.1.6 para el caso con OpenMP.


En el caso de OpenMP resalta claramente como influye utilizar una excesiva cantidad de hilos en Cardumen para muy pocos datos. Notar que lso tiempos tienden a ser levemente menores para mas de \~4000 partículas.


Comparación del algoritmo original (1.0.1) con el algoritmo modificado 1.1.6 para el caso con PThreads.


Aquí también se puede observar el costo que tiene utilizar muchos threads con pocos datos. En éste caso se hace notoria la mejora de rendimiento entre las dos versiones de PThreads en Cardumen. No puede faltar un gráfico con todos los resultados: ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- [![](http://2.bp.blogspot.com/-p_pFWFl8nTs/Tp27gcmfdOI/AAAAAAAAA3Q/Slf_J4wIgxQ/s1600/comparacion_algoritmos_todos.png)](http://2.bp.blogspot.com/-p_pFWFl8nTs/Tp27gcmfdOI/AAAAAAAAA3Q/Slf_J4wIgxQ/s1600/comparacion_algoritmos_todos.png) Todos los resultados juntos. -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
[¿Podemos mejorar aún mas el algoritmo?]{.Apple-style-span style="font-size: large;"} Si, y (teóricamente) mucho. El "truco" está en reducir la complejidad del algoritmo lo mas posible. Para eso hay que detectar el cuello de botella, que no es otro que el cálculo de las fuerzas entre cada partícula. Dijimos que la interacción entre las mismas es una relación de la distancia. Pero lo que no nombramos es que, luego de una cierta distancia *r*, ya no interactúan entre ellas. Debemos entonces encontrar una forma de que cada partícula solo calcule la fuerza que podrían llegar a ofrecerles posibles partículas aledañas. Una posible solución sería dividir el espacio bidimensional en una matriz donde cada casillero sea de tamaño *r*x*r*. Cada vez que se mueve una partícula se la ubica en el casillero correspondiente a su zona final. Luego basta considerar sólo las fuerzas que aplican las partículas en el mismo casillero y en los casilleros aledaños. Si bien suena sencillo, se hace necesario sincronizar el acceso a cada partícula entre los hilos y sus propiedades. Yo no llegué a implementarlo, pero [MorningCoffee si lo ha hecho](https://github.com/Morningcoffee/ID1217--Parallelize-Particle-Simulation). Lamentablemente tampoco lo llegué a probar :-( [Haciendo trabajar a Cardumen]{.Apple-style-span style="font-size: large;"} Ahora la idea no es analizar el algoritmo sino como responde el servidor con ése algoritmo ante distintas cargas y números de threads. ::: {.separator style="clear: both; text-align: center;"} [![](http://3.bp.blogspot.com/-rxKECYDRClk/Tp4WlNJD6xI/AAAAAAAAA6o/qQKSocD9IBo/s1600/tiempo_vs_numero_particulas_openmp.png)](http://3.bp.blogspot.com/-rxKECYDRClk/Tp4WlNJD6xI/AAAAAAAAA6o/qQKSocD9IBo/s1600/tiempo_vs_numero_particulas_openmp.png) ::: En el caso de OpenMP podemos ver como se va incrementando el costo fijo de generar una cantidad determinada de threads.  Podemos ver que, para muy pocas partículas (hasta \~20), tener un **solo hilo** de OpenMP (que debería ser el mismo caso que el algoritmo totalmente serial) tiene un overhead. También se puede observar que dada una cierta cantidad de partículas realmente vale la pena usar paralelización. ::: {.separator style="clear: both; text-align: center;"} [![](http://2.bp.blogspot.com/-nt8h0evBx4Y/Tp4WuTeab8I/AAAAAAAAA6w/HT8dSkGT_U4/s1600/tiempo_vs_numero_particulas_pthreads.png)](http://2.bp.blogspot.com/-nt8h0evBx4Y/Tp4WuTeab8I/AAAAAAAAA6w/HT8dSkGT_U4/s1600/tiempo_vs_numero_particulas_pthreads.png) ::: ::: {.separator style="clear: both; text-align: center;"} ::: El mismo análisis se puede hacer para PThreads. ::: {.separator style="clear: both; text-align: center;"} [![](http://4.bp.blogspot.com/-R22e_laWiAs/Tp4W6M-I_xI/AAAAAAAAA64/4SavtekBqiE/s1600/tiempo_vs_numero_particulas_todos.png)](http://4.bp.blogspot.com/-R22e_laWiAs/Tp4W6M-I_xI/AAAAAAAAA64/4SavtekBqiE/s1600/tiempo_vs_numero_particulas_todos.png) ::: ::: {.separator style="clear: both; text-align: center;"} ::: Y, por supuesto, podemos ver todos los resultados juntos. Las referencias corresponden a la simulación serial, luego las de OpenMP terminando con las de PThreads. Veamos ahora el speedup de cada caso: ::: {.separator style="clear: both; text-align: center;"} [![](http://2.bp.blogspot.com/-ZJOacDOCass/Tp4XEmdsoWI/AAAAAAAAA7A/kKSFafGDCK8/s1600/speedup_particulas_openmp.png)](http://2.bp.blogspot.com/-ZJOacDOCass/Tp4XEmdsoWI/AAAAAAAAA7A/kKSFafGDCK8/s1600/speedup_particulas_openmp.png) ::: ::: {.separator style="clear: both; text-align: center;"} ::: Puede verse que la performance de PThreads es similar. ::: {.separator style="clear: both; text-align: center;"} [![](http://4.bp.blogspot.com/-5WSc1u74SEI/Tp4XUK0I6JI/AAAAAAAAA7I/oT5g6hYcPEA/s1600/speedup_particulas_pthreads.png)](http://4.bp.blogspot.com/-5WSc1u74SEI/Tp4XUK0I6JI/AAAAAAAAA7I/oT5g6hYcPEA/s1600/speedup_particulas_pthreads.png) ::: Resulta posible observar que en ambos casos el speedup se aproxima al teórico para cada número de threads. ¿Y que pasaría si tuviésemos una cantidad **fija** de threads para utilizar? ::: {.separator style="clear: both; text-align: center;"} [![](http://2.bp.blogspot.com/-vdcqLejWIuI/Tp4XcLKB0sI/AAAAAAAAA7Q/xiB6CkdF-Hg/s1600/tiempo_calculo_numero_threads.png)](http://2.bp.blogspot.com/-vdcqLejWIuI/Tp4XcLKB0sI/AAAAAAAAA7Q/xiB6CkdF-Hg/s1600/tiempo_calculo_numero_threads.png) ::: ::: {.separator style="clear: both; text-align: center;"} ::: [¿Tenés los resultados a mano?]{.Apple-style-span style="font-size: large;"} Si, pueden obtenerlos [acá](http://dumbledore.com.ar/gitweb/?p=hpc/resultados_particulas.git;a=summary). [Binarizando imágenes]{.Apple-style-span style="font-size: x-large;"} La idea de la segunda parte del TP es binarizar dos juegos de 100 imágenes de 360 y 1080 pixeles cada uno. Primero resolver el problema de forma serial y luego paralelizarlo. Visto gráficamente, la idea es pasar de una imagen como: ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- [![](http://2.bp.blogspot.com/-NmTguzcG0-Q/Tp3ZdCHIYmI/AAAAAAAAA4A/vamE2C_2rZk/s640/big_buck_bunny_00399.png){width="640" height="360"}](http://2.bp.blogspot.com/-NmTguzcG0-Q/Tp3ZdCHIYmI/AAAAAAAAA4A/vamE2C_2rZk/s1600/big_buck_bunny_00399.png) \(c\) copyright 2008, Blender Foundation / www.bigbuckbunny.org. Bajo licencia CC-BY 3.0. ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- A una imagen con solo dos tonos: ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ [![](http://2.bp.blogspot.com/-htYRUbjcns8/Tp3ZoSNYcsI/AAAAAAAAA4I/rkT5z2X4ocs/s640/big_buck_bunny_00399_bin.png){width="640" height="360"}](http://2.bp.blogspot.com/-htYRUbjcns8/Tp3ZoSNYcsI/AAAAAAAAA4I/rkT5z2X4ocs/s1600/big_buck_bunny_00399_bin.png) \(c\) copyright 2008, Blender Foundation / www.bigbuckbunny.org. Bajo licencia CC-BY 3.0. Modificado por mi código :-) ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ Para lograr ésto usé [Qt](http://en.wikipedia.org/wiki/Qt_(framework)). no lo hice la manera mas eficiente, ya que utilicé QImage::pixel() y QImage::setPixel(). Podría haber utilizado los métodos de QImage para acceder a los pixeles como vecotres de datos. Pero bueno, para el propósito de éste TP, alcanza. Aproveché el envión que llevo de aprender [CMake](http://en.wikipedia.org/wiki/CMake) y lo usé para compilar. Se los recomiendo. El código fuente lo pueden encontrar [acá](http://dumbledore.com.ar/gitweb/?p=hpc/binarizacion.git;a=summary). [La estrategia]{.Apple-style-span style="font-size: large;"} Tan sencilla como hacer que cada hilo se ocupe de procesar una imagen. No hay interdependencia entre ellas, por lo que no es necesario sincronizar los threads. Dicho de otra manera, no hay necesidad de procesar las imágenes en ningún orden en particular. [Los gráficos obtenidos]{.Apple-style-span style="font-size: large;"} Podemos ver el tiempo de ejecución vs. el número de threads: ::: {.separator style="clear: both; text-align: center;"} [![](http://3.bp.blogspot.com/-4_NxWLmmYls/Tp3dwigiAzI/AAAAAAAAA4Q/v6Fyq3Deri4/s1600/tiempo_vs_n_threads_360.png)](http://3.bp.blogspot.com/-4_NxWLmmYls/Tp3dwigiAzI/AAAAAAAAA4Q/v6Fyq3Deri4/s1600/tiempo_vs_n_threads_360.png) ::: Es interesante ver la meseta que se forma entre los \~8 y \~20 threads. ::: {.separator style="clear: both; text-align: center;"} [![](http://3.bp.blogspot.com/-dHlbIzKgEIQ/Tp3d0lMnV1I/AAAAAAAAA4Y/gYzY16EfYhk/s1600/tiempo_vs_n_threads_1080.png)](http://3.bp.blogspot.com/-dHlbIzKgEIQ/Tp3d0lMnV1I/AAAAAAAAA4Y/gYzY16EfYhk/s1600/tiempo_vs_n_threads_1080.png) ::: En éste caso, la meseta no aparece. Y también podemos medir el speedup. En amarillo, el speedup teórico ideal. ::: {.separator style="clear: both; text-align: center;"} [![](http://3.bp.blogspot.com/-_LrampTmvXg/Tp3d60LvHLI/AAAAAAAAA4g/fN6C14Xipb8/s1600/speedup_vs_n_threads_360.png)](http://3.bp.blogspot.com/-_LrampTmvXg/Tp3d60LvHLI/AAAAAAAAA4g/fN6C14Xipb8/s1600/speedup_vs_n_threads_360.png) ::: ::: {.separator style="clear: both; text-align: center;"} [![](http://1.bp.blogspot.com/-r97ADEjp4Xo/Tp3d-QeRrKI/AAAAAAAAA4o/FNUjHf2k1qU/s1600/speedup_vs_n_threads_1080.png)](http://1.bp.blogspot.com/-r97ADEjp4Xo/Tp3d-QeRrKI/AAAAAAAAA4o/FNUjHf2k1qU/s1600/speedup_vs_n_threads_1080.png) ::: Realmente me sorpendió lo bajo del speedup :-/ Como nota al margen, Cardumen empezó a dar "Bus error" al momento de correr los algoritmos (entre ejecución y ejecución). Es posible que haya un problema de hardware en el mismo. [¿Y los resultados?]{.Apple-style-span style="font-size: large;"} También están disponibles [acá](http://dumbledore.com.ar/gitweb/?p=hpc/resultados_binarizacion.git;a=summary). [Algunas conclusiones]{.Apple-style-span style="font-size: x-large;"} - OpenMP hace la vida de un programador mucho mas sencilla que PThreads por poca o nada de diferencia en tiempo de ejecución. - Esperaba que el Sparc tuviese un mejor rendimiento. Mi sospecha es que no se trata de un servidor diseñado para procesar datos de punto flotante (posee una sola FPU por core, es decir, una FPU por cada 8 hilos). - Estaría bueno poder decirle a OpenMP/Sistema Operativo que ponga un hilo por core. hasta donde sé, pueden crearse 8 hilos pero no hay ninguna garantía de que cada uno corra en un core. Ésto serviría para reducir el tiempo en cálculos con mucho uso de FPU.

Comments


There are no comments yet.

Add a Comment

You can use the Markdown syntax to format your comment.

Comment Atom Feed