CUDA [II] Instalación de toolkit y SDK para CUDA

Buenooo. Ahora nos dejamos ya de palabras y empezamos haciendo algo interesante. Pero antes quiero hacer un par de notitas:

1. Vamos a instalar drivers nuevos. Lo más fácil es que los drivers nuevos no funcionarán a la primera o vete a saber tu qué. Entiendase que se puede liar la cosa.
2. Hay gente que ha conseguido instalar todo el SDK y todo en Ubuntu 9.10. Yo no puede/supe. Lo he probado en Ubuntu 9.04 y ha funcionado perfectamente. El soporte de nVidia llega hasta 9.04.
3. AVISO. El material que voy a poner aqui, en su mayoría van a ser cópido de otras páginas. Como podeis imaginar hay mucha gente que ha hablado hasta ahora del proceso de instalación, lo que la información está un poco "separada". Yo os pondré lo que me ha funcionado a mi, a modo de recopilación/traducción. No dejen de visitar las fuentes originales.
   
4. Comprueben que sus tarjetas sean compatibles con CUDA.
   

Dados estos avisos, empezemos.

[INSTALANDO 9.04]
Tuve muchos problemas en Ubuntu 9.10. Como nVidia da soporte a Ubuntu 9.04 me dije, pues instalalo. Y esto hice. He creado una partición en mi disco y he instalado 9.04. Os recomiendo que hagais igual, si os quereis ahorrar problemas. Además, así podeis hacer las pruebas que querais sin miedo a perder datos ni nada. La instalación tiene que ser nativa! No virtualizeis!

[INSTALANDO DRIVERS][1]
Una vez tenemos nuestro 9.04 funcionando y operativo, debemos instalar los últimos drivers de nVidia, los 195. Para ello seguiremos estos pasos:
$ sudo su
$ echo DRIVERS NVIDIA 195 >> /etc/apt/sources.list
$ echo deb http://ppa.launchpad.net/nvidia-vdpau/ppa/ubuntu jaunty main >> /etc/apt/sources.list
$ echo deb-src http://ppa.launchpad.net/nvidia-vdpau/ppa/ubuntu jaunty main >> /etc/apt/sources.list
$ apt-key adv --keyserver keyserver.ubuntu.com --recv-keys CEC06767
$ aptitude update
$ aptitude install nvidia-195-modaliases nvidia-glx-195

[DESCARGANDO PAQUETES]
Tenemos que ir a la pagina web de CUDA, a descargas. Los paquetes que necesitamos son:

• CUDA Toolkit for Ubuntu Linux 9.04
• GPU Computing SDK code samples and more

La versión 32bits o 64 bits. Como corresponda. Los descargamos en el escritorio.

[INSTALANDO TOOLKIT] [2]
Para ello damos permisos de ejecución con el comando:
$ chmod +x ~/Escritorio/cudatoolkit_3.0_linux_32_ubuntu9.04.run
Y ahora lo instalaremos. Pero resulta que al instalarlo, si tenemos GDM iniciado, da un error. Para esto utilizaremos una consola tty1. Apunta los pasos ya que cerraremos GDM y te vas a quedar sin gestor de ventanas. Será solo un momento.

• Pulsamos Control+Alt+F1
• Entramos con un usuarios que tenga privilegios administrativos
• $ sudo service gdm stop
• $ cd /home/nombre_del_usuario/Escritorio
• $ sudo ./cudatoolkit_3.0_linux_32_ubuntu9.04.run
• $ sudo service gdm start
• Pulsamos Control+Alt+F7, iniciamos sesion normalmente y seguimos el proceso

Ahora tenemos que añadir los directorios de nvidia a PATH. Abrimos un terminal:

• $ sudo vim /etc/bash.bash.rc #Si no sabes usar vim, pon "gedit" en lugar de "vim"
  
• Al final del fichero incluiremos dos líneas:

export PATH=${PATH}:/usr/local/cuda/bin
export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:/usr/local/cuda/lib64

Si tenemos un sistema de 32 bits, cambiamos "lib64" por "lib". Guardamos el fichero y Toolkit instalado.

[INSTALANDO EL SDK][2]
Hacemos el fichero ejecutable con:
$ chmod +x ~/Escritorio/gpucomputingsdk_3.0_linux.run
No hace falta que se instale con privilegios de ROOT. Instalar con el usuario que va a usar el SDK.
$ ./gpucomputingsdk_3.0_linux.run
Las preguntas que nos hace las contestamos con un "enter". El default ya nos sirve. Una vez instalado entramos en la carpeta del SDK:
$ cd ~/NVIDIA_GPU_Computing_SDK/C
Instalamos dependencias:
$ sudo aptitude install freeglut3 freeglut3-dev libx11-dev mesa-common-dev libxmu6 libxi-dev libxmu-dev
Y compilamos los codigos:
$ make

[EJECUTANDO EJEMPLOS][2]
Si todo ha funcionado correctamente, ahora podremos ejecutar los siguientes comandos:
$ cd ~/NVIDIA_GPU_Computing_SDK/C/bin/linux/released
$ ./deviceQuery
$ ./fluidsGL
$ ./smokeParticles
$ ./particles

[POSIBLES PROBLEMAS]

• El compilador gcc tiene que ser verión 4.3 ( en mi caso 4.3.3 ). El compilador 4.4 no funciona directamente. Diríganse a [2] para ver como se puede "arreglar" el problema.
• Es muy importante tener instalado ( y funcionando ) los últimos drivers de nVidia. El SDK funciona solo con los drivers más nuevos.
• Links dónde encontré respuestas que ayudaron a aclararme: [3] [4]
• De dependencias. Pero siguiendo los pasos anteriores deberían quedar todas cubiertas.
  

[1] Via: dame-linux. Un post simple, fácil y para toda la familia. No dejen de hecharle un vistazo.
[2] Vía stealthcopter Fué el mejor post que encontré. Lo instalan en 9.10, pero a mi no me llegó a funcionar. Yo lo he traducido y adaptado a 9.04, pero es una copia de este post.
[3] Foro de nVidia. Problemas a la ejecución de algunas demos.
[4] Foro de nVidia. Error con ficheros gl.h glu.h

CUDA [I] Introducción sobre tarjetas gráficas

[Sobre que me voy a enrollar hoy]
Hace tiempo ya, me picó el gusanillo de la programación de GPU's [1]. Es por todos conocido que las tarjetas gráficas tienen una alta capacidad de procesamiento y que se necesitan para jugar a los juegos de nueva generación. Pero, por que son tan potentes?

[Explicación]
Resulta que este tipo de hardware ha sido pensado para trabajar con mucha paralelización, es decir, muchos cálculos hechos al mismo tiempo.
Para ello, las tarjetas gráficas tienen un reloj relativamente bajo como 500MHz, o 1GHz. Y vosotros me direis: "Si ya! Pero mi PC tiene un procesador de 2.5GHz, esto es más rapido!" Y es cierto, la única diferencia es que lo más seguro es que tu procesador solo tenga un core. Y en el mejor de los casos va a tener dos o cuatro cores.

La diferencia fundamental es que las tarjetas gráficas tienen 64, 128, 256 o incluso 480 cores! Esto significa que cada uno de los 64 cores, por ejemplo, tiene una velocidad de 500MHz. Lo que una simple multiplicación (0.5GHz por 64 cores ) nos da una asombrosa velocidad de reloj de 32GHz. Eso, señores, es bastante mas que 2.5GHz. Se pueden imaginar las últimas tarjetas gráficas como la GTX 480: 480 cores a 1,401GHz = 672 GHz!!

Bien, pero no nos dejemos engañar por las cifras. 672GHz es la capacidad que puede desarrollar una tarjeta haciendo CÁLCULOS PARALELIZABLES! Osea, esto incluye toda una metodología de programación diferente a la "programación tradicional", y no todos los cálculos són paralelizables, claro! Por este motivo tenemos un procesador y una tarjeta gráfica. El procesador se encarga de los programas "unicore" ( no es una afirmación del todo cierta, ahora os lo cuento) y tiene una velociad de reloj relativamente alta, por otra parte la tarjeta gráfica se encarga de ejecutar aplicaciones que pueden ser altamente paralelizables como, [surprise surpriseee], la renderización de imágenes que es lo que se usa en los juegos. Para ello usa velocidades de reloj bajas, pero muchos cores.

Aprovechando que hablo del tema: los procesadores convencionales, a su vez, también disponen de varios cores, osea que realmente también podemos echar las mismas cuentas: Si el procesador es de 2.5GHz y tenemos 4 cores, el procesador tendrá una potencia de 10GHz para procesos paralelizables. Muy importante destacar esto último. La mayoría de programas no utilizan los diferentes cores de un procesador. Por lo que los programas pensados del modo "tradicional" trabajarían a una velocidad de reloj de 2.5GHz, mientras que los que han sido pensados para ser paralelizados trabajarían a una velocidad de 10GHz como máximo ( insisto en esto ).

[Ejemplo serializable]
Vamos a poner un ejemplo: Imaginemos que tenemos 128 números ( vamos a hacer números "redondos" 2^7 ) y queremos comprobar si son números primos o no. Nosotros programamos en un lenguaje convencional como C, por ejemplo, una función de es_primo(numero). Esta función recibe un número determinado, y devuelve verdadero o falso dependiendo si es primo o no. Bien. Pues si tenemos 128 números a comprobar lo que hará el programa será algo así:
Procesador1:

• es_primo(1)
• es_primo(2)
• es_primo(3)
• es_primo(...)
• es_primo(127)
• es_primo(128)

Bien! Entonces, cada llamada a la función es_primo() tardará 1 unidad de tiempo ( es un ejemplo ). Con lo que si llamamos 128 veces a la función tardaremos 128 unidades de tiempo. ok?

Imaginamos que hemos hecho el programa de modo que nosotros utilizamos una tarjeta gráfica que *casualmente* tiene 128 cores. Lo que podemos hacer es asignar a cada uno de los cores un trabajo concreto. Solo le asignamos el trabajo, todavía no lo ejecutamos! Vean:

• Core1: es_primo(1)
• Core2: es_primo(2)
• Core3: es_primo(3)
• CoreN: es_primo(N)
• Core128: es_primo(128)

Y ahora, una vez le hemos asignado el trabajo a cada uno de los cores, les decimos a cada uno de ellos: ejecutad. Y todos, a la vez, van a hacer el cálculo. A la vez. Lo que significa que vamos a estar 1 unidad de tiempo para hacer todos los cálculos. Asombroso, verdad? Pero claro, ahora estaréis pensando. Justamente has hecho un ejemplo donde el número de cores són iguales a los números que queremos comprobar!! Vaaaale. Cierto, veamos un último ejemplo. Imaginemos que tenemos una gráfica con solo 64 cores. Seguimos queriendo calcular 128 números. Entonces asignamos dos números a cada core, de modo que queda algo así:

• Core1: es_primo(1) es_primo(2)
• Core2: es_primo(3) es_primo(4)
• Core3: es_primo(5) es_primo(5)
• CoreN: es_primo(n) es_primo(n+1)
• Core128: es_primo(127) es_primo(128)

De este modo, cuando el Core1 acabe de ejecutar "es_primo(1)", empezará a ejecutar "es_primo(2)". Cuando demos la orden a todos los cores de que empiezen su trabajo, tardarán 2 unidades de tiempo en realizar el trabajo, ya que cada uno tiene que hacer dos cálculos, pero todos harán sus dos cálculos a la vez. Interesante, verdad?

**Nota: en el ejemplo se considera que el coste de comprobar es_primo(1) es igual a es_primo(128), aunque en realidad no tiene el mismo coste computacional. Es solo para que el ejemplo se entienda.

[Ejemplo no serializable]
Calcular los decimales del número PI. PI no puede calcularse en "partes". No le puedo decir al Core1, cálculame los decimales de PI de 1 a 100 y al Core2 que me calcule los decimales de 101 hasta 200 ya que para calcular los decimales de 101 al 200 se necesita haber encontrado los decimales de 1 a 100. Este cálculo lo hará mejor el procesador, ya que trabaja a una velocidad de reloj más alta.

[Tecnología]
Pues al tener una gráfica de nvidia ( 9600GT ), me ha apetecido probar de programarla. Para ello hay un lenguaje de programación, CUDA. Este lenguaje, que es muy parecido a C, nos permite programar y compilar los programas para que se ejecuten el la/las gráficas que tengamos instaladas. Para ello usaré ubuntu 9.04 ( ya explicaré por qué ) los drivers 195 de nVidia y el SDK que dan en su pagina web.

[Resumiendo...]
CUDA mola. Aprendamos a programar. En la próxima entrega os explico como instalar todo el SDK para programar en CUDA (ardua tarea). Espero no haberles aburrido mucho!