IMPLEMENTACIÓN DE MOVING LEAST SQUARES USANDO LA GPU

Transcripción

1 UNVERSIDAD DE CARABOBO FACULTAD EXPERIMENTAL DE CIENCIAS Y TECNOLOGÍA DEPARTAMENTO DE COMPUTACIÓN INFORME FINAL DE PASANTÍAS: IMPLEMENTACIÓN DE MOVING LEAST SQUARES USANDO LA GPU Elaborado por: Daniela Alexandra González Gutíerrez Tutor Académico: Jorge Rodríguez Tutor Empresarial: Máximo Mero Presentado ante la Ilustre Universidad de Carabobo como requisito parcial para optar al título de Licenciado en Computación 2013

2 Índice 1. Resumen 5 2. Justificación 6 3. Descripción de la Organización 7 4. Objetivos logrados durante la pasantía Estudio de la arquitectura de la GPU CUDA en profundidad Hardware de la GPU Arquitectura SIMT Capacidad de Cómputo Estudio de la programación en la GPU con CUDA Implementar algoritmos del álgebra matricial sobre la GPU Métodos sin malla Realizar un estudio referente a los métodos numéricos LS, WLS y MLS Least Squares Weighted Least Squares Moving Least Squares Aplicaciones de Mínimos Cuadrados Móviles Implementación del Método de Mínimos Cuadrados Móviles Pseudocódigo del Algoritmo de Mínimos Cuadrados Móviles Métodos, procedimientos, materiales y equipos utilizados Resulados obtenidos, análisis de los mismos y conclusiones 53 1

3 7. Limitaciones y Recomendaciones Glosario 55 Índice de cuadros 1. Comparación de Tiempos CPU vs GPU Comparación de Tiempos CPU vs GPU MLS Compiladores y Editor de Texto Utilizado Equipo utilizado Índice de figuras 1. Modelo de ejecución en CUDA Ejecución paralela de un grupo de 8 threads Ejemplo de sincronización de threads grid de N bloques de threads Gestión de escalabilidad Jerarquía de Memoria Distribución de threads y Blocks [11] Distribución de memoria en detalle [11] Asignación de Blocks a los Streaming Multiprocessors Hardware de la GPU con CUDA [11] Especificaciones técnicas según la Capacidad de Cómputo Arquitectura CPU - GPU Jerarquía de threads [11] Matriz I del Algoritmo en la GPU

4 15. Matriz J del Algoritmo en la GPU Matriz R del Algoritmo en la GPU Gráfico del Algoritmo en la GPU Muestra Gráfico del Algoritmo en la GPU Muestra Gráfico del Algoritmo en la GPU Muestra MLS sobre la GPU con 1681 puntos Muestra MLS sobre la GPU con 4489 puntos Muestra MLS sobre la GPU con puntos Muestra MLS sobre la GPU con puntos Muestra MLS sobre la GPU con puntos Muestra MLS sobre la GPU con puntos con Muestra MLS sobre la GPU con puntos con Muestra MLS sobre la GPU con puntos con Muestra MLS sobre la GPU con puntos con Muestra MLS sobre la GPU con puntos con Muestra MLS sobre la GPU con puntos con Muestra MLS sobre la GPU con puntos con Muestra MLS sobre la GPU con puntos con Muestra Vista 1 de muestra 5 con 256 puntos de entrada y de salida Vista 2 de muestra 5 con 256 puntos de entrada y de salida Vista 1 de muestra 5 con 256 puntos de entrada y de salida Vista 2 de muestra 5 con 256 puntos de entrada y de salida Vista 1 de muestra 3 con 256 puntos de entrada y 1681 de salida Vista 2 de muestra 3 con 256 puntos de entrada y 1681 de salida Muestra 3 con 512 puntos de entrada y de salida

5 40. Muestra 4 con 256 puntos de entrada y de salida Muestra 4 con 256 puntos de entrada y de salida List of Algorithms 1. Definición de un kernel con CUDA MLS

6 1. Resumen Tradicionalmente, los programas del ordenador han sido escritos para la computación en serie. Para resolver un problema, los algoritmos se contruyen e implementan como un flujo instrucciones en serie. Estas instrucciones son ejecutadas en una unidad central de procesamiento (CPU) donde sólo se puede ejecutar una instrucción a la vez y cuando ésta ha finalizado, se ejecuta la siguiente. En contraposición, la computación paralela usa simultáneamente múltiples elementos de procesamiento para resolver un problema. Esto se consigue dividiendo el problema en partes independientes para que cada elemento de procesamiento pueda ejecutar su parte del algoritmo simultáneamente con los otros. Los elementos de procesamientos son diversos y pueden incluir desde un único computador con múltiples procesadores a varios computadores conectados en red o bien hardware más especializado. Hasta la fecha existen multitud de aplicaciones limitadas por la potencia de la CPU que podrían aprovechar la potencia de la computación paralela en la Unidad de Procesamiento Gráfico Graphics Processing Unit (GPU). Puesto que los procesadores multi-core y las GPUs llevan la computación paralela a todos los consumidores entonces, el reto está en la transición de los desarrolladores y la industria del software hacia esta técnica de programación. Este proyecto ha abordado la implementación de la aproximación por Mínimos Cuadrados Móviles (Moving Least Squares) utilizando las capacidades de la computación paralela haciendo uso de la GPU mediante el lenguaje de programación CUDA, así como también se ha implementado en la CPU usando el lenguaje C++. En primer lugar se ha estudiado la computación paralela en la GPU mediante CUDA (Compute Unified Device Architecture, en español, Arquitectura Unificada de Dispositivos de Cómputo) de la empresa especializada en el desarrollo de unidades de procesamiento gráfico y tecnologías de circuitos integrados NVIDIA. También se ha aplicado dicha herramienta para la implementación de varias de las operaciones matriciales básicas como lo son la suma, resta y multiplicación, e inversa, además se ha investigado y estudiado lo referente a los métodos de aproximación por mínimos cuadrados, entre los cuales están el clásico Least Squares (LS), Weighted Least Squares (WLS) y Moving Least Squares (MLS). 5

7 2. Justificación Los Mínimos Cuadrados Móviles han sido implementados y son de gran éxito en áreas como la Computación Gráfica donde sirven para recontruir superficies a partir de puntos adquiridos a partir scanners 3D, interpolación y aproximación de superficies implícitas, simulación y animación, deformación de imágenes 3D, entre otros, con resultados muy buenos en comparación con otros métodos, sin embargo, este método obtiene sus buenos resultados a un coste bastante elevado debido a la gran cantidad de cálculos a realizar cuando se tiene una gran cantidad de datos. Por otro lado, debido a los límites físicos y energéticos que no permiten que los procesadores sigan creciendo en número de transistores, la solución adoptada es incluir cada vez más cores, tanto en la CPU como en la GPU. Esto es un claro indicador de que el futuro va encaminado hacia la computación paralela. Además, hoy en día las GPUs ofecen una capacidad de cómputo bastante elevada. CUDA ha irrumpido con fuerza y cada vez más desarrolladores y empresas están aprovechando en sus aplicaciones los beneficios que ofrece la computación paralela en la GPU. Un desarrollador que sepa aprovechar las capacidades que ofrece la computación paralela en la GPU puede obtener aumentos de rendimiento realmente increíbles en sus aplicaciones. Algunos ejemplos serían las famosas suites Photoshop y Premiere de Adobe que a partir de su versión CS4 permiten la aceleración por CUDA aumentando de manera considerable la velocidad de ejecucíon en algunas de las tareas que realizan, o bien el codificador de video Badaboom que gracias a la aceleración por GPU es capaz de codificar videos en mucho menos tiempo del que se necesita en una CPU. Por estas razones se ha decidido dar uso a la programación paralela mediante CUDA como lenguaje de programación, para así aprovechar la capacidad de cálculo de la GPU en la implementación del método de Mínimos Cuadrados Móviles y así lograr una optimización del mismo. 6

8 3. Descripción de la Organización La Universidad de Carabobo, cuenta con el Centro Multidisciplinario de Visualización y Cómputo Científico los threads se puedes agrupar en bloq(cemvicc), el cual es un grupo de investigación que tiene como finalidad solucionar las distintas problemáticas en el ámbito científico y tecnológico que necesiten de visualización de datos, computo de alto rendimiento, construcción de modelos matemáticos para la obtener las respuestas a los problemas planteados en diversas áreas. El CEMVICC planteó, como trabajo de pasantía, el análisis, diseño e implementación de la aproximación por Mínimos Cuadrados Móviles utilizada para suavizar e interpolar datos haciendo uso de la GPU. Las ecuaciones que fueron programadas y que generan la aproximación fueron implementadas siguiendo un esquema similar al propuesto por Lancaster y Salkauskas [7] quienes fueron las personas que propusieron por primera vez este método numérico. Los procedimientos necesarios para realizar cálculos para la aproximación fueron implementadas en el lenguaje de programación CUDA, para así hacer uso de la programación paralela que ofrecen las tarjetas gráficas NVIDIA y así optimizar el tiempo de ejecución del método MLS. Cabe mencionar que el rol realizado en la pasantía fue de Investigador y Programador. 7

9 4. Objetivos logrados durante la pasantía Objetivo General Implementar el método numérico Moving Least Squares (MLS) usando la programación de la GPU Objetivos Específicos 1. Estudiar la arquitectura de la GPU 2. Estudiar la programación en la GPU con CUDA 3. Implementar algoritmos del álgebra matricial sobre la GPU 4. Estudiar lo referente a los métodos numéricos LS, WLS y MLS 5. Implementar el Método de Mínimos Cuadrados Móviles 4.1. Estudio de la arquitectura de la GPU Mucho ha ocurrido desde los inicios de la informática gráfica, desde el primer hardware monocromático integrado en las placas base hasta las modernas tarjetas gráficas. Su aparición no es exclusiva de los computadores personales, sino que también se pueden encontrar tarjetas gráficas en una gran variedad de sistemas como videoconsolas, asistente digital personal (PDA) y teléfonos móviles. La gran novedad de la programación usando la GPU, Graphics Processing Unit, de NVIDIA es la posibilidad de usar los procesadores de la tarjeta gráfica para realizar cálculo paralelo por medio de CUDA. En general, los sistemas informáticos están pensados para realizar todos los cálculos de procesamiento con el microprocesador integrado (como por ejemplo Intel Core i7, i5, i3 o un microprocesador de AMD entre otros). Gracias a la arquitectura de cálculo paralelo inventada por NVIDIA es posible realizar cálculos tanto en la CPU (procesador del ordenador integrado en la placa base) como en la GPU (procesador gráfico integrado dentro de las tarjetas gráficas). De esta forma, es posible realizar coprocesamiento compartido entre la CPU y la GPU. Este hecho no ha pasado desapercibido a los científicos e ingenieros, los cuales han conseguido incrementar en cientos de veces su potencia de cálculo. Hasta la fecha, un microprocesador Intel o AMD tiene un máximo de 4 ó 6 núcleos, que pueden ser hasta 12 con la tecnología de Intel HyperThreading, mientras los procesadores gráficos,(cuda core), de las tarjetas de NVIDIA pueden llegar hasta 3072 núcleos de procesamiento paralelo. La capacidad de procesamiento no sólo de 12 núcleos sino también incluyendo 3072 más aumenta el rendimiento y permite la posibilidad de que el programador pueda lanzar decenas de miles de threads mejorando las capacidades de computación de forma impresionante. La característica principal de la programación en CUDA permite combinar la implementación de código secuencial en la CPU ( host) con la implementación de código paralelo en la GPU (dispositivo). De esta manera se consigue entrelazar ejecuciones de código en serie con ejecuciones de rutinas, llamadas kernels, escritas en código en paralelo mediante CUDA. 8

10 Figura 1: Modelo de ejecución en CUDA La ejecución en el dispositivo se realiza por un conjunto finito de threads que trabajan en paralelo y actúan cada uno sobre una parte diferente de los datos. De esta forma podemos definir como kernel a un conjunto determinado de threads concurrentes, donde sólo un kernel es ejecutado al mismo tiempo en el dispositivo, y muchos threads participan el la ejecución del kernel. Cada thread tiene su propio identificador para poder realizar un paralelismo transparente sobre los datos. Figura 2: Ejecución paralela de un grupo de 8 threads Como puede observarse en la figura 2, los 8 threads lanzados realizan un procesamiento sobre la zona respectiva de los datos asociada a cada thread, almacenando la salida en cada zona de datos respectiva a cada identificador. Los threads se pueden agrupar en bloques, de esta forma podemos entender a un kernel como una malla de bloques de threads. Debemos tener presente que la sincronización de threads dentro de un bloque debe realizarse con barreras (barriers): 9

11 Figura 3: Ejemplo de sincronización de threads En este ejemplo, los threads implicados en (1), después de realizar su procesamiento deben esperar hasta que todos los threads de su grupo alcancen la primitiva synctrheads, (2), para poder entrar en la nueva parte de procesamiento (3). Figura 4: grid de N bloques de threads A partir de este modelo, mientras los threads de dentro de un bloque sí se pueden sincronizar, los bloques de threads no permiten sincronización entre ellos; aunque la arquitectura de CUDA permite su ejecución en cualquier orden, concurrentemente o en serie. Por lo tanto, se considera que existe una barrera de sincronización implícita entre dos kernels lanzados consecutivamente. Como consecuencia, esta independencia proporciona una gran escalabilidad, donde los grids se escalan dependiendo del número de núcleos paralelos. 10

12 Figura 5: Gestión de escalabilidad Respecto a la jerarquía de memoria, es imprescindible destacar que existen tres tipos de memoria que caracterizan la arquitectura CUDA. La primera de ellas es la memoria local dedicada a cada thread. Ésta es sin duda la parte de la memoria que es privativa a un único thread y se encuentra dentro del ambiente de la función que implementa el kernel. Es la memoria para datos locales y utilizada exclusivamente para operaciones implementadas en la misma función. En segundo lugar, tenemos la memoria compartida. Este tipo de memoria permite que varios threads compartan información entre ellos cuando se ejecutan dentro de un mismo kernel, permitiendo principalmente optimizar el rendimiento. Por último, tenemos la memoria global reservada para propósitos de almacenamientos de datos de entrada y resultados del kernel. En la siguiente imagen podemos distinguir los diferentes tipos de memoria: 11

13 Figura 6: Jerarquía de Memoria CUDA en profundidad Ahora que se han visto las características principales de la arquitectura CUDA, se pasará a describir con más detalle cada una de las partes vistas anteriormente. Se prosigue con la estructura de threads y bloques de un kernel. Como se ha comentado antes, tanto los threads como los bloques, contienen un identificador unívoco que permite distinguirlos durante la ejecución. De esta forma, el programador puede, por medio de los identificadores, decidir sobre qué datos trabajar independientemente de lo que hagan otros threads. Así, un programador puede decidir sobre qué parte de los datos proporcionados al kernel debe acceder un thread cuando se ejecute su porción de código que también ejecutarán otros threads con sus identificadores. Los identificadores de los bloques pueden ser unidimensionales (1D) o bidimensionales (2D), mientras que los identificadores de los threads pueden ser unidimensionales, bidimensionales o tridimensionales (3D). Esto simplifica enormemente el direccionamiento de memoria para datos multidimensionales, por lo que puede ser muy útil en procesamiento de imágenes y resolución de problemas matemáticos complejos que impliquen matrices. 12

14 Figura 7: Distribución de threads y Blocks [11] Con respecto a la distribución de memoria se tiene: 13

15 Figura 8: Distribución de memoria en detalle [11] Como puede verse en la figura 8, existe una estructura de registros para los propósitos del thread, utilizada para intercambio de datos entre el procesador y la memoria, así como operaciones escalares. Existen un total de 8192 registros repartidos entre los diferentes bloques de threads en ejecución. Los threads pueden leer y escribir en los registros de propósito general con un tiempo de ejecución muy pequeño. La memoria local permite el almacenamiento de datos locales del propio kernel: los threads pueden leer y escribir en esta memoria los datos que le sean necesarios. En esta memoria privada para cada thread se almacenan datos para la pila y las variables locales. La memoria compartida, que tiene una capacidad de 16 KB, permite intercambiar información entre los threads de un mismo bloque, por ejemplo en operaciones de reducción. Esta memoria también permite la lectura y escritura desde los threads que pertenecen al mismo bloque. Por último, tenemos tres tipos de memoria más extensas y ubicadas en la memoria DRAM de la tarjeta. Éstas son la memoria global, con una capacidad de hasta 1.5 GB, permite tanto a todos los threads como al host leer y escribir en ella en común; la memoria constante que permite un alto rendimiento y tiene una 14

16 capacidad de 64 KB con 8 KB de memoria caché permite a todos los threads leer el mismo valor de memoria constante simultáneamente en un ciclo de reloj. El tiempo de acceso a la memoria constante es similar al de los registros y sólo admite lectura desde los threads y lectura/escritura desde el host. La memoria de texturas está optimizada para aprovechar la localidad espacial de dos dimensiones. De esta forma, se consigue mejor rendimiento a medida que los threads del mismo warp acceden a direcciones más cercanas de la memoria. Al igual que la memoria constante, sólo permite lectura desde los threads y lectura/escritura desde el host Hardware de la GPU La GPU CUDA contiene un conjunto de N 1 Streaming Multiprocessors, donde cada Streaming Multiprocessor es un conjunto de 8 a 32 Streaming Processors o también llamados CUDA cores, esta cantidad depende del tipo de arquitectura de la GPU (Tesla, Fermi, Kepler, Maxwell). Cada Streaming Multiprocessor crea, planifica y ejecuta hasta 24 warps 2 pertenecientes a uno o más bloques (768 threads). De esta forma, cada warp ejecuta una instrucción en 4 ciclos de reloj. Como fue descrito en la figura 5, cada bloque se asigna a un núcleo (core) o Streaming Multiprocessor, y un Streaming Multiprocessor asigna a cada bloque los recursos necesarios (contextos de threads, registros, etc.). Figura 9: Asignación de Blocks a los Streaming Multiprocessors La ejecucion de los threads en la GPU no se lleva a cabo de forma independiente. El planificador de threads, como su nombre lo indica, planifica y distribuye bloques de threads entre los Streaming Multiprocessor. Siguiendo el ejemplo de la figura 9, cada Streaming Multiprocessor puede ejecutar hasta ocho bloques de 1 En el dispositivo G80 hay un total de 16 multiprocesadores 2 Un bloque se divide en grupos de 32 threads denominados warps 15

17 forma simultánea, siempre que se cumplan todas las restricciones sobre los recursos del multiprocesador. Una aplicación común ejecuta más de 240 bloques (30*8), por lo tanto, es tarea del planificador mantener una lista de los bloques estalecidos e ir asignando bloques a los streaming multiprocessor según terminen. Cuando una aplicación invoca a un kernel de CUDA, los bloques de threads son enumerados y distribuidos a los diferentes streaming multiprocessors disponibles. Los threads del bloque de threads se ejecutan concurrentemente en un streaming multiprocessor y múltiples bloques de threads se pueden ejecutar concurrentemente en un streaming multiprocessor. Cuando un bloque de threads termina su ejecución, nuevos bloques de threads se lanzan en el streaming multiprocessor que ha quedado libre. De esta forma, sólo con ampliar el número de streaming multiprocessors la velocidad de ejecución de una aplicación CUDA aumentará, ya que podrán ejecutarse más bloques de threads a la vez Un streaming multiprocessor está diseñado para ejecutar cientos de threads concurrentemente. Para manejar esta gran cantidad de threads, utiliza una arquitectura llamada Single-Instruction, Multiple-Thread (SIMT) Arquitectura SIMT El multiprocesador crea, maneja, pone en cola y ejecuta los threads en grupos de 32 threads paralelos llamados warps. Todos los threads que componen un warp empiezan en la misma dirección del programa, pero tienen libertad de ramificarse y ejecutarse independientemente. Cuando un multiprocesador recibe uno o más bloques de threads para ejecutar lo divide en warps que son puestos en cola por el planificador de warps (warp scheduler) para su ejecución. La manera en que ocurre esta división es siempre la misma, cada warp contiene threads con identificaciones consecutivas, donde el primer warp contiene el thread con identificación 0. Un warp ejecuta una instrucción común a la vez, por lo tanto se conseguirá rendimiento máximo cuando los 32 threads de un warp mantengan el mismo camino de ejecución y no haya threads que tomen caminos distintos ya que entonces la ejecución del warp se serializaría. Es importante tener en cuenta dos casos especiales sobre la ejecución de instrucciones de un warp: Cuando un warp ejecuta una instrucción no-atómica que escribe en una misma posición de memoria de la memoria global (global memory) o de la memoria compartida (shared memory) para más de uno de los threads del warp, el número de escrituras serializadas en esa posicón varía dependiendo de la capacidad de cómputo del dispositivo y no se sabe que thread ha realizado la última escritura. Cuando un warp ejecuta una instrucción atómica de lectura, modificación o escritura en una misma posición de memoria de la memoria global para más de uno de los threads del warp, cada lectura, modificación o escritura a esa posición se serializa y se ejecutan todas en un orden indefinido. 16

18 Figura 10: Hardware de la GPU con CUDA [11] Capacidad de Cómputo Éxiste un término que es importante conocer a la hora de saber las características de la GPU sobre la cual se está programando, éste es la Capacidad de Cómputo (Compute Capability), quien está definida por un número de revisión mayor y otro menor donde cada número indica una serie de caracterísicas. Cada GPU de NVIDIA tiene una capacidad de cómputo y es importante saber para qué versión se está programando, ya que las características varían de una versión a otra. Por ejemplo, acceder a de manera óptima a la memoria 17

19 global en un dispositivo con capacidad de cómputo 1.0 es más complicado que con uno de capacidad de cómputo 1.3 ya que los requisitos son más estrictos. El número de revisión mayor indica a qué arquitectura pertenece el dispositivo: 1 para todas las arquitecturas de NVIDIA compatibles con CUDA 2 para la nueva arquitectura FERMI El número de resivión menor indica diferentes mejoras incrementales que se han producido a los cores o a nuevas caracterísicas que se han ido añadiendo dentro de una misma arquitectura. [4] Figura 11: Especificaciones técnicas según la Capacidad de Cómputo 4.2. Estudio de la programación en la GPU con CUDA El éxito de las GPUs en los últimos años reside en la facilidad del modelo de programación paralela usando CUDA. En este modelo, el desarrollador de la aplicación modifica ésta para asignar a la GPU los kernels más complejos desde el punto de vista computacional. El resto de la aplicación permanece en la CPU. Asignar una función a la GPU implica reescribir ésta para aprovechar el paralelismo del procesador gráfico y agregar palabras clave de CUDA para transferir los datos hacia y desde la GPU. El programador se encarga de lanzar decenas de miles de procesos (threads) de forma simultánea. El hardware de la GPU maneja estos procesos y programa su ejecución. Durante la pasantía realizada se ha adquirido conocimientos acerca de algunos tópicos de la Programación de propósito general utilizando la tarjeta gráfica de la computadora. Esto se ha conseguido haciendo uso del lenguaje de programación CUDA, el cual permite la programación de las tarjetas gráficas NVIDIA. El lenguaje de programación CUDA (Compute Unified Device Architecture) está basado en lenguajes que se ejecutan sobre la CPU tales C y/o C++, sin embargo, al momento de implementar un mólulo en el cual se requiere paralelismo se hace uso de las palabras reservadas de CUDA, éstas le indican al compilador de CUDA que ese fragmento de código se ejecutará en la GPU. 18

20 Para programar en CUDA se deben diseñar algoritmos enfocados al trabajo en paralelo para un procedimiento dado. Al ejecutarse un código en CUDA habrá una parte que cargará los datos necesarios para la aplicación y posteriormente se procederá a enviar esos datos a la GPU para realizar los respectivos cálculos en paralelo. Usualmente se implementa un código a ejecutar en la CPU y otro en la GPU para realizar pruebas y comprobar que la forma de almacenamiento y manejo de memoria en la GPU es la idónea y que los resultados arrojados son los correctos. El modelo de programación CUDA asume que los threads de CUDA se ejecntas distutan en una unidad física distinta que actúa como coprocesador (device) al procesador (host) donde se ejecuta el programa (ver figura 12). CUDA C es una extensión del lenguaje de programación C, que permite al programador definir funciones C, llamadas kernels, que, al ser invocadas, se ejecutan en paralelo por N hilos diferentes. Los kernels se ejecutan de forma secuencial en el device 3. [6] Figura 12: Arquitectura CPU - GPU kernels CUDA extiende el lenguaje de programación C permitiendo a los programadores definir funciones especiales llamadas kernels. Estas funciones, cuando son invocadas, se ejecutan N veces en paralelo por N diferentes CUDA threads, en contraposición a la única vez que sería ejecutada en una función C regular. Un kernel se define usando la declaración global que permite que la función sea llamada desde el host pero sólo se pueda ejecutar desde el device. El número de threads que ejecuta un kernel se define en la llamada a la función usando la sintaxis <<<número de bloques, número de threads, tamaño en bytes de la memoria compartida (opcional), stream ID (opcional)>>>. A esto se le llama configuración del kernel. Cada thread que ejecuta el kernel tiene asociada una identidad única que es accesible dentro del kernel a través de la variable threadidx incorporada. Un kernel a su vez, puede ciomar a otras funciones si son declaradas mediante la declaración device y sólo pueden ser llamadas de la GPU, es decir, dentro del procedimiento global Como ejemplo, el siguiente código muestra cómo se define un kernel y cómo se llaman desde un programa: 3 Con la llegada de la nueva generación de GPUs, la arquitectura Fermi (chip GF100), es posible ejecutar kernels en paralelo 19

21 Algorithm 1: Definición de un kernel con CUDA begin // Definición del Kernel global void vectadd(float A, float B, float C) { int i = threadidx.x C[i] = A[i] + B[i] } int main() {... // Invocación del kernel con N threads vectadd<<< 1, N >>> (A, B, C) } end Existe una jerarquía perfectamente definida sobre los threads de CUDA. Los threads se agrupan en vectores a los que se les llama bloques, estos vectores pueden ser de una, dos o tres dimensiones, de forma que definen bloques de threads de una, dos o tres dimensiones. threads del mismo bloque pueden cooperar entre sí, compartiendo datos y sincronizando sus ejecuciones. Sin embargo, threads de distintos bloques no pueden cooperar. Los bloques a su vez, se organizan en una grid de bloques. Este grid, puede ser de una o dos dimensiones. Figura 13: Jerarquía de threads [11] Como puede verse, cada thread queda perfectamente identificado por un ID de bloque y el ID del propio thread dentro del bloque. Estos IDs suelen usarse como índice para definir qué porciones de los datos procesa cada hilo. Esto puede verse en el código anterior. 20

22 Cada thread tiene acceso a distintos tipos de memoria. En primer lugar una memoria local al propio thread, esta memoria se aloja en la memoria principal de la GPU (off-chip). Además todos los threads de un mismo bloque comparten una región de memoria compartida (on-chip) para comunicarse entre ellos, la memoria compartida tiene el mismo tiempo de vida que el bloque de threads. Por último, todos los threads tienen acceso a la misma memoria global (device memory). Ejemplo práctico: La programacón en CUDA se basa en la ejecución en paralelo de operaciones o asignaciones, en donde se podría decir que se disponen de los threads para realizar una operación atómica, como por ejemplo, la asignación de M(i, j) = A(i, j) + B(i, j), con M, A y B matrices N*N, en este caso, cada (i, j), sería ejecutado por un thread, por lo tanto se necesitarían N*N threads y en el código en CUDA no se reflejarían ciclos para recorrer las matrices, como ocurre habitualmente en la programación secuencial, pues todas estas asignaciones se realizarían en paralelo. Aunque parezca que todos los tipos de problemas o algoritmos se podrían adecuar a una implementación en CUDA, esto no es cierto, pues se considera una falacia pensar que todos los algoritmos son susceptibles de adaptarse al paralelismo de las GPUs. Así, mientras que las CPUs se orientan a optimizar la ejecución de aplicaciones de propósito general, las GPUs son dedicadas a obtener un mayor rendimiento y de procesamiento gráfico. Por otro lado, se ha podido apreciar que la característica principal de la programación en CUDA es que permite combinar la implementación de código secuencial en el host con la implementación de código en paralelo en el dispositivo. De esta manera se consigue entrelazar ejecuciones en serie con ejecuciones paralelas en los kernel Implementar algoritmos del álgebra matricial sobre la GPU Como parte de la práctica de la programación sobre la GPU y para su posible uso dentro de los métodos numéricos sin malla se han implementado algunas operaciones matriciales en CUDA. Ahora bien, se podría preguntar porqué necesariamente se necesitaría implementar fragmentos de código en CUDA, la respuesta se ha vuelto práctica ya que probando códigos que fueron implementados en la GPU, en comparación con códigos implementados en la CPU, se ha evidenciado que los programas ejecutados haciendo uso de la GPU son mucho más rápidos que los de la CPU cuando las exigencias son elevadas, por ejemplo, en una multiplicación de matrices de 5120x5120 el tiempo que tarda CUDA para realizar estos cálculos es de segundos mientras que la CPU (siendo éste un procesador Intel Core i7, del cual se tienen 4 núcleos virtuales y 4 reales) tarda s, lo que hace a la GPU en esta prueba, veces más rápida que la CPU, siendo ésta una cifra bastante significativa. Respecto a la suma de matrices, también fue imlementada en la GPU y arrojó buenos resultados, en matrices de 5120x5120 tardó s en su ejecución, claro está, que en el caso de suma de matrices no se necesita realizar gran cantidad de cálculos como en la multiplicación, entonces no se evidencia gran diferencia entre su ejecución en la CPU que tardó s, sin embargo, el código implementado en CUDA se ejecuta 2.16 veces más rápido que el implementado en CPU. Se ha implementado la resta de matrices, la cual, por tener la misma característica que la suma, tampoco evidencia gran diferencia en el tiempo de ejecución entre la GPU y la CPU. Se ejecutó una resta de matrices de 5120x5120 que en CUDA tardó s, mientras que en la CPU se ejecutó en s siendo 21

23 la GPU 2.15 veces más rápida que la CPU en esta prueba. Por último, se ha implementado el cálculo de la inversa de una matriz, la misma se ha conseguido calcular haciendo uso de los valores singulares de la matriz y su factorización SVD (Singular Value Descomposition) para lograr abordar matrices tanto que tengan o no inversa. Esta factorización se logró utilizando la librería CULA. En las pruebas de este tipo y con una matriz de 256x256 el algoritmo programado en la CPU tuvo un tiempo de ejecución de 0.84 s mientras que en la GPU tardó 0.62 s, lo que les deja casi parejos, sin embargo, con una matriz de 2048x2048, el tiempo de ejecución en la CPU ha sido de s mientras que en la GPU fue s, siendo el algoritmo implementado en la GPU 6.36 veces más rápido. Ello nos indica que conforme a que la matriz es más grande el algoritmo en la GPU es superior al de la CPU. Operación Tamaño de la Matriz Tiempo CPU Tiempo CUDA Multiplicación de Matrices 256* s s Multiplicación de Matrices 512* s s Multiplicación de Matrices 1024* s s Multiplicación de Matrices 2048* s s Multiplicación de Matrices 5120* s s Suma de Matrices 256* s s Suma de Matrices 512* s s Suma de Matrices 1024* s s Suma de Matrices 2048* s s Suma de Matrices 5120* s s Resta de Matrices 256* s s Resta de Matrices 512* s s Resta de Matrices 1024* s s Resta de Matrices 2048* s s Resta de Matrices 5120* s s Inversa de una matriz 256* s 0.62 s Inversa de una matriz 512* s 1.67 s Inversa de una matriz 1024* s 6.36 s Inversa de una matriz 2048* s s Cuadro 1: Comparación de Tiempos CPU vs GPU 4.4. Métodos sin malla Los denominados métodos sin malla han atraido muy recientemente el interés de los investigadores, debido a su flexibilidad para resolver problemas prácticos de simulación numérica. El principal objetico de los métodos sin malla es superar las dificultades que aparecen en los problemas de simulación numérica al tener que mallar remallar los dominios en estudio, ya que en estos métodos es suficiente con añadir nodos donde sea necesario. Se trata por tanto de nuevos métodos de computación que pueden cambiar el actual enfoque de los métodos de simulación. Los métodos sin mallas son aquellos donde el objeto es modelado por medio de una nube de partículas sin conectividad previa. Existe una diversidad de métodos sin mallas y los más destacados son: SPH (Smoothed Particle Hydrodynamics), DEM (Method Element Difuse),EFG (Element Free Galerkin), Mínimos Cuadrados (Moving Least-Squares), LBIE (Local Boundary Integral Equation), PUM (Partition of Unity Method). El método de SPH fue desarrollado originalmente en 1977 para la simulación de gas interestelar en el campo 22

24 de la astro física. Fue desarrollado por Bob Gingold y Joe Monaghan [5] e independientemente por Leon Lucy [8]. El método SPH es un método poderoso que permite la solución de problemas dinámicos complejos tanto de fluidos como de otros materiales. Desde su desarrollo ha sido usado exitosamente en mútiples áreas de estudio tales como: rompimiento de oleaje, flujo de lava, estudio de fracturas elásticas, problemas de superficie libre y materia granular. La aproximación de los mínimos cuadrados (MLS - Moving Least-Squares) fue desarrollada por Lancaster y Salkauskas en 1981 [7], quienes fueron los primeros que usaron la aproximación de MLS para el suavizado e interpolación de datos en el área de computación gráfica. Este método se describirá con mayor detalle en secciones próximas Realizar un estudio referente a los métodos numéricos LS, WLS y MLS Least Squares Los Mínimos cuadrados es una técnica de aproximación numérica de una función u(x) a partir de su valor en ciertos puntos {x i... x n } pertenecientes a algún conjunto Ω R d donde i [1... N]. Se quiere obtener una función definida globalmente f(x) que se aproxime a los valores escalares dados f i en los puntos x i en el sentido de mínimos cuadrados con el error funcional J LS = i f(x i ) f i 2 Por lo tanto, se plantea el problema de minimización siguiente mín f f(x i ) f i 2, (1) d m i donde f es tomada de d m, el espacio de polinomios de grado total m en d dimensiones espaciales, y puede ser escrito como f(x) = b(x) T c = b(x) c, (2) donde b(x) = [b 1 (x),..., b k (x)] T es el vector de base polinomial y c = [c 1..., c k ] T es el vector de coeficientes desconocidos que se desean miminizar en ( 1). Algunos ejemplos de bases polinomiales son (a) para m = 2 y d = 2, b(x) = [1, x, y, x 2, xy, y 2 ] T, (b) para un ajuste lineal en R 3 (m = 1, d = 3), b(x) = [1, x, y, z] T, y (c) para el montaje de una constante en dimensiones arbitrarias b(x) = [1]. En general, el número k de elementos en b(x) (y por tanto en c) es dado por k = (d+m)! m!d! Solución Se puede minimizar ( 1) al establecer las derivadas parciales del error funcional J LS a cero, i.e, J LS = 0 donde = [ c1,..., ck ] T que es una condición necesaria para un mínimo. Al tomar derivadas parciales con respecto a los coeficientes desconocidos c 1,..., c k, se obtiene un sistema de ecuaciones lineales de donde se puede calcular c [10] 23

25 J LS c1 = 0 : J LS c2 = 0 : J LS c3 = 0 :. 2b 1 (x i )[b(x i ) T c f i ] = 0 i 2b 2 (x i )[b(x i ) T c f i ] = 0 i 2b 3 (x i )[b(x i ) T c f i ] = 0 i (3) En notatición Matriz-Vector esto se escribe como: 2b(x i )[b(x i ) T c f i ] = 2 i i [b(x i )b(x i ) T c b(x i )f i ] = 0 (4) Dividiendo por la constante y reordenando se obtiene el siguiente LSE: b(x i )b(x i ) T c = i i b(x i )f i, (5) Que se resuelve como c = [ i b(x i )b(x i ) T ] 1 i b(x i )f i, (6) Si la matriz cuadrada A LS = i b(x i)b(x i ) T es no singular, i.e det(a LS ) 0, sustituyendo Ecc. (6) en Ecc (2) se obtiene la función de ajuste f(x). Para k pequeños (k < 5) la inversión de la matriz en la Ecc. (6) puede llevarse a cabo de forma explícita, de lo contrario métodos numéricos son la herramienta preferida. Ejemplo. Dados los puntos en R 2 y se desea ajustar con una cuadrática, polinomio bivariado, i.e. d = 2, m = 2 y por lo tanto b(x) = [1, x, y, x 2, xy, y 2 ] T entonces el LSE resultante se ve así: 1 x i y i x 2 i x i y i yi 2 c 1 x i x 2 i x i y i x 3 i x 2 i y i x i yi 2 y i x i y i yi 2 x 2 i y c 2 i x i yi 2 yi 3 i x 2 i x 3 i x 2 i y i x 4 i x 3 i y c 3 i x 2 i y2 i x i y i x 2 i y i x i yi 2 x 3 i y c 4 = i x 2 i y2 i x i yi 3 i c 5 yi 2 x i yi 2 yi 3 x 2 i y2 i x i yi 3 yi 4 c 6 1 x i y i x 2 i x i y i yi 2 f i. (7) Método de Ecuaciones Normales. Para una notación diferente pero también muy común, se debe tener en cuenta que la solución para c en la ecuación. (5) resuelve el siguiente (generalmente sobre-restringida) LSE (Bc = f) en el sentido de mínimos cuadrados. 24

26 , usando el método de ecuaciones normales b T (x 1 ). b T (x N ) c = f 1. f N (8) B T Bc =B T f c =(B T B) 1 B T f. Si se observa con detenimiento, la ecuación (6) y la ecuación (9) son idénticas. (9) Weighted Least Squares Formulación del Problema. En la formulación del Weighted Least Squares se utiliza el error funcional J W LS = i θ( x x i ) f(x i ) f i 2 para un punto estimado x R d que se minimiza mín f d m θ( x x i ) f(x i ) f i 2, (10) i similar a (1) sólo que ahora el error es ponderado por θ(d) donde d i son las distancias euclidianas entre x y las posiciones de los puntos de la data x i. Los coeficientes desconocidos que se deben obtener desde la solución a (10) son ponderados por las distancias a x y por lo tanto una función x. Así, la local, aproximación de mínimos cuadrados ponderados en x se escribe como f x (x) = b(x) T c( x) = b(x) c( x), (11) y sólo define localmente dentro de una distancia R alrededor de x, i.e. x x < R. Función de Peso. Muchas opciones para la función de ponderación θ se han propuesto en la literatura, tal como una gaussiana θ(d) = e d2 h 2 (12) donde h es un parámetro de espaciado que se puede utilizar para suavizar los rasgos pequeños en los datos. Otra función de ponderación popular con soporte compacto es la función Wendland. θ(d) = ( 1 d ) 4 ( ) 4d h h + 1 Esta función está bien definida en el intervalo d [h, 0], y, además θ(0) = 1, θ(h) = 0, θ (h) = 0, θ (h) = 0. Varios autores sugieren usar funciones de peso de la siguiente forma: ( ) 1 θ(d) = d 2 + ε 2 (14) Es de hacer notar que establecer el parámetro ε a cero da como resultado una singularidad en d = 0, lo que obliga a la función de ajuste de la MLS a interpolar los datos. (13) 25

27 Solución. Análogo al LS, se toma derivadas parciales del error funcional J W LS con respecto a los coeficientes desconocidos c( x) θ(d i )2b(x i )[b(x i ) T c( x) f i ] = i 2 (15) [θ(d i )b(x i )b(x i ) T c( x) θ(d i )b(x i )f i ] =0, i donde d i = x x i. Dividiendo entre la constante y reordenando se tiene θ(d i )b(x i )b(x i ) T c( x) = θ(d i )b(x i )f i, (16) i i y despejando los coeficientes c( x) = [ i θ(d i )b(x i )b(x i ) T ] 1 i θ(d i )b(x i )f i ], (17) La única diferencia entre las ecuaciones (6) y (17) son los términos de ponderación. Observe de nuevo, sin embargo, que mientras que los coeficientes c en la ecuación (6) son globales, los coeficientes c( x) son locales y tienen que ser recalculados para cada x. Si la matriz cuadrada A W LS = i θ(d i)b(x i )b(x i ) T (a menudo se denomina Matriz Momento) es no singular (i.e. det(a W LS ) 0), sustituyendo la ecuación (17) en la ecuación (11) se obtiene la función de ajuste f x (x). Aproximación Global usando una Partición de la Unidad PU. Ajustando polinomios a j [1... n] los puntos estimados y discretos x j en el parámetro de dominio Ω se pueden ensamblar en una aproximación global a la data garantizando que cada punto en Ω está cubierto por al menos un polinomio de aproximación, es decir, el soporte de las funciones de peso θ j centrado en los puntos x j que cubren Ω Ω = j supp(θ j ). (18) La ponderación adecuada de estas aproximaciones se puede lograr mediante la construcción de una partición de la unidad (PU) desde θ j θ j (x) ϕ j (x) = n k=1 θ (19) k(x) donde j ϕ i(x) 1 en todo Ω. La aproximación global viene a ser f(x) = j ϕ j (x)b(x) T c( x j ). (20) Una cuestión numérica. Para evitar inestabilidades numéricas con posibles números grandes en A W LS puede ser beneficioso llevar a cabo el procedimiento de ajuste en un sistema de coordenadas local con respecto a x, es decir, para cambiar x en el origen. Por lo tanto, se reescribe la función de ajuste local en x como f x (x) = b(x x) T c( x) = b(x x) c( x), (21) los coeficientes asociados como c( x) = [ i θ(d i )b(x i x)b(x i x) T ] 1 i θ(d i )b(x i x)f i, (22) 26

28 y la aproximación global como f(x) = j ϕ j (x)b(x x j ) T c( x j ). (23) Moving Least Squares Método. El Moving Least Squares fue propuesto por Lancaster and Salkauskas [7] para suavizar e interpolar datos. Esta técnica de aproximación es una variante de la aproximación por mínimos cuadrados ponderados, con la particularidad de que ahora la función de peso se traslada de un punto a otro, de manera que el máximo está en el punto x donde se quiere obtener el valor aproximado, por ello el nombre de mínimos cuadrados móviles [2]. Esto se lleva a cabo fácilmente si se asocian unos pesos positivos W i (los cuales van a depender de x) a cada punto y se minimiza. La idea es iniciar con una formulación de mínimos cuadrados ponderados para un punto fijo arbitrario en R d, a continuación mover este punto sobre el dominio entero, donde se calcula un mínimo cuadrado ponderado y se evalua para cada punto individualmente. Se puede demostrar que la función global f(x), obtenida a partir de un conjunto de funciones locales f(x) = f x (x), mín f d m θ( x x i ) f x (x i ) f i 2, (24) i es continuamente diferenciable si y sólo si la función de ponderación es continuamente diferenciable. Además θ( x x i ) es positiva, grande para los puntos x cercanos a x i, y relativamente pequeña para los x más distantes. diferencia θ( x x i ) decrece monótonamente al aumentar la diferencia x x i hasta valer cero (soporte compacto). Así que en lugar de construir la aproximación global utilizando la ec. (20), se utiliza ecs. (11) y (17) (o (21) y (22)) y se construye y evalua un polinomio local adaptado continuamente a lo largo de todo el dominio Ω, lo que resulta en la función de ajuste MLS. Para el caso general, cuando el sistema es de r dimensiones x = [x 1, x 2,..., x r ] y se quiere aproximar una función f(x), el funcional J pasa a ser ahora de la siguiente manera: J = j w j (x x j )(P T (x j )c(x) f j ) 2 (25) y en forma matricial J = (P c(x) f) T W (x)(p c(x) f) (26) Donde f es el vector de n 1 valores nodales y P la matriz de n m siendo n el número de puntos y m el número de términos del polinomio aproximador (base polinomial), y W (x) es la matriz diagonal de la función de ponderación 27

29 W = diag[w(x x i ),..., w(x x n )] (27) derivando se obtiene J c = A(x)c(x) B(x)f = 0 (28) donde A(x) =P T W (x)p B(x) =P T W (x) (29) y por lo tanto c(x) = A(x) 1 B(x)f (30) en esta ocación los coeficientes de la matriz c(x), dependen de x, debido a la inclusión de la función de ponderación en el funcional, de forma que la función de aproximación queda f(x) = p(x) T A(x) 1 B(x)f (31) donde p(x) es la base polinomial evaluada en cada x y y perteneciente al dominio discretizado, p(x) = [1, x, y, x 2, xy, y 2 ] T Utilizando (14) como la función de ponderación con un ε muy pequeño asigna pesos cercanos al infinito cerca de los puntos de entrada de datos, obligando a la función de ajuste MLS a interpolar los valores de la función prescrita en estos puntos. Por lo tanto, mediante la variación de ε se puede influir directamente en la aproximacion / interpolación de la naturaleza de la función de ajuste MLS. O también se puede hacer uso de la función de ponderación exponencial (12) con un radio de soporte entre 0 y 1 con la cual se pueden obtener excelentes resultados Aplicaciones de Mínimos Cuadrados Móviles Diseñada originalmente para el tratamiento de datos y la generación de superficies, la ténica de Mínimos Cuadrados Móviles se ha vuelto muy popular entre los grupos de investigación que trabajan con métodos sin malla, siendo ampliamente utilizada en aplicaciones tanto eulerianas como lagrangianas. Esta clase de métodos de aproximación es particularmente competitiva en la reconstrucción de una determinada función y sus derivadas sucesivas a partir de los valores de dicha función en una serie de puntos dispersos. Se ha pretendido que el empleo de Mínimos Cuadrados Móviles proporcione algo parecido a unas funciones de forma para esquemas de volúmenes finitos en mallas no estructuradas, representando una interesante alternativa a los métodos existentes en la actualidad, así como también hacer uso del método en aplicaciones en problemas de flujo de fluidos comprensibles. En general, el MLS es un método bastante útil a la hora de reconstruir superficies a partir de puntos [1], simulaciones [3], animaciones [9], interpolación y aproximación de superficies implícitas [12] 28

30 4.6. Implementación del Método de Mínimos Cuadrados Móviles Luego del estudio de los famosos métodos de mínimos cuadradados, se escogió el método de MLS (Moving Least Squares) o Mínimos Cuadrados Móviles, porque ofrecía mejores resultados de aproximación. Como se observó en la sección teórica, es el método que requiere más cálculos matriciales que muchas veces toman gran cantidad de tiempo de ejecución. Sin embargo, dado los estudios realizados a la programación en la GPU mediante el lenguaje de programación CUDA se ha podido conseguir un buen resultado en tiempo de ejecución y en obtención de la solución. Este algoritmo, fue implementado en CUDA 4.2 y se utilizó también la librería basada en CUDA llamada CULA Dense R14 versión Free para obtener los valores singulares y utilizarles para implementar la operación inversa de una matriz. Fue de gran provecho la multiplicación de matrices en la GPU, ya que se realiza para matrices grandes en corto tiempo con respecto a la CPU. Las primeras pruebas se realizaron con pocos puntos en la data, con nueve (9) puntos exactamente, comparando los resultados con otro algoritmo de MLS que fue programado bajo el lenguaje C++ (por lo tanto en la CPU). Se pudo notar que fueron correctos los resultados obtenidos por MLS bajo CUDA en este caso de 9 puntos de entrada, y se consiguieron en el mismo tiempo aproximadamente ya que como se observó en la sección de implementación de los algoritmos del álgebra matricial, en principio, para matrices no muy grandes la multiplicación de matrices es bastante rápida en la CPU, el problema viene a ser con matrices más grandes. Algo importante de señalar es que, debido a las operaciones matriciales y a la configuración del kernel, se requiere que preferiblemente se suministre al programa una cantidad de puntos que sea de la forma K 16, es decir, múltiplo de 16, si la cantidad de data inicial supera los 16 puntos. Se realizaron las pruebas usando una base polinomial b(x) = [1, x, y, x 2, xy, y 2 ] T y considerando un conjunto de nueve puntos en 2D P i = {(1, 1), (1, 1), ( 1, 1), ( 1, 1), (0, 0), (1, 0), ( 1, 0), (0, 1), (0, 1)} con el conjunto de valores de función asociados f i = {1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0}. Además, se hizo uso de la función de peso exponencial (12) con un radio de soporte (h) de 0.6 y se hizo un refinamiento usando una grid con los puntos (x, y) distribuidos con una distancia de 0.1 entre ellos, y se encuentran ubicados en las matrices I y J respectivamente y los resultados de las imágenes de los puntos calculados con el MLS se almacenan en una matriz R. Recorrer las matrices I y J en paralelo provee la combinación de los pares (x i, y i ) en una grid que se abarca el dominio de los puntos de la data dada, y además recorrer I, J y R en paralelo da como resultado para cada (x, y) su imagen z, la cual se encuentra en la matriz R, para de esa manera hacer un refinamiento de los datos que en principio era sólo nueve (9) pares (x i, y i ) con sus respectivas imágenes f i. En algunos gráficos comparativos que se muestran a continuación se puede apreciar que la aproximación de MLS efectivamente se ajusta, en este caso, los puntos generados por el método estan en color azul y los de la data inicial esta en color rojo. 29

31 Figura 14: Matriz I del Algoritmo en la GPU Figura 15: Matriz J del Algoritmo en la GPU Figura 16: Matriz R del Algoritmo en la GPU 30

32 Figura 17: Gráfico del Algoritmo en la GPU Muestra 1 Figura 18: Gráfico del Algoritmo en la GPU Muestra 1 31

33 Figura 19: Gráfico del Algoritmo en la GPU Muestra 1 32

34 Figura 20: MLS sobre la GPU con 1681 puntos Muestra 1 33

35 Figura 21: MLS sobre la GPU con 4489 puntos Muestra 1 34

36 Figura 22: MLS sobre la GPU con puntos Muestra 1 35

37 Figura 23: MLS sobre la GPU con puntos Muestra 1 36

38 Figura 24: MLS sobre la GPU con puntos Muestra 1 37

39 Figura 25: MLS sobre la GPU con puntos con Muestra 1 38

40 Figura 26: MLS sobre la GPU con puntos con Muestra 1 39

41 Figura 27: MLS sobre la GPU con puntos con Muestra 1 40

42 Figura 28: MLS sobre la GPU con puntos con Muestra 1 41

43 Figura 29: MLS sobre la GPU con puntos con Muestra 2 42

44 Figura 30: MLS sobre la GPU con puntos con Muestra 2 43

45 Figura 31: MLS sobre la GPU con puntos con Muestra 2 44

46 Figura 32: MLS sobre la GPU con puntos con Muestra 2 También se realizaron pruebas con otro tipo de datos de entrada, con diferente cantidad de puntos, con rangos entre 256 y 1024 puntos, con lo cuales se pudo apreciar una diferencia entre el tiempo de ejecución favorable para el algoritmo programado haciendo uso de la GPU. Arrojando los siguientes resultados: 45

47 Cantidad de datos de entrada Cantidad de puntos a generar Tiempo GPU Tiempo CPU s 1.61 s s 5.02 s s s s s s 2.11 s s 7.43 s s s s s s s s s s s s s s s s s Cuadro 2: Comparación de Tiempos CPU vs GPU MLS De esto se puede decir que la GPU fue casi 8 veces más rápida que la CPU en las pruebas de 1024 puntos de entrada, fue 2 veces más rápida en las pruebas con 512 puntos de entrada, 1.5 veces más rápida con 256 datos de entrada y por último estuvo casi pareja con la entrada de 9 puntos. Las capturas de pantalla de algunas de estas pruebas se pueden observar en las siguientes figuras: Figura 33: Vista 1 de muestra 5 con 256 puntos de entrada y de salida 46