2. Présentation du CEPC : GPGPU
CPU vs GPU : pourquoi GPGPU ?
Les GPU nous fournissent une bande passante et
une puissance de calcul énorme et pour pas
cher, exemple :
GeForce 6800 : 35Gb/sec pour ~100€
ATI X800 : 63GFlops pour ~150€
Pentium IV SSE 3.7Ghz : 14.8GFlops ~535€
Ils sont à la pointe des technologies (>300millions
de transistors, 110nano …)
Une carte dernière génération ~500€ et ça tombe
très rapidement.
3. Présentation du CEPC : GPGPU
Aperçu Général d’une carte graphique
Sur une carte graphique moderne 90% de la surface est dédier à
la 3D
Les GPU modernes sont architecturés autours d’un pipeline
destiné à maintenir un fort débit grâce à la parallélisassions.
Depuis quelques années, ils sont devenus « programmable ». Et
depuis 2002 supportent les calculs flottant
L’apparition d’un langage Assembleur à accéléré les choses.
Optional chapter number (Arial 10 plain)
2005 : L’OpenGL Board à officialisé les
extensions Pixel et Vertex Shader, facilitant
ainsi les développements
4. Présentation du CEPC : GPGPU
Stream processing
Conventional, sequential paradigm
for(int i = 0; i < 100 * 4; i++)
result[i] = source0[i] + source1[i];
Parallel SIMD paradigm, packed registers (SWAR)
for(int el = 0; el < 100; el++) // for each vector
vector_sum(result[el], source0[el], source1[el]);
Parallel Stream paradigm (SIMD/MIMD)
// This is a fictional language for demonstration purposes.
streamElements 100 streamElementFormat 4 numbers
elementKernel "@arg0+@arg1" result = kernel(source0,
source1)
5. Présentation du CEPC : GPGPU
Concept 1 : Tableau = Texture
Notre but : pour 2 vecteurs x et y de longeur N et un scalaire alpha, on veut calculer
: y = y + alpha * x (encore appeler saxpy() )
Les tableaux à 1 dimension sont les éléments naturels des CPUs : a[i][j] c’est un
tableau de tableau de taille MxN.
Sur les GPUs les données natives sont à 2 dimensions.
On travaille sur 4 données en même temps (RGBA).
A la place de notre tableau on aura une texture 2D de taille MxN.
Il faudra mettre en place un mapping entre les indices et le pixels.
Les textures sont : soit Readable, soit Writable, jamais les deux !
6. Présentation du CEPC : GPGPU
Concept 2 : Kernels = Shaders
implémentation CPU oriente boucle vs kernel et data-parallele.
Typiquement sur un CPU on aura :
for (int i=0; i<N; i++)
dataY[i] = dataY[i] + alpha * dataX[i];
L’objectif sur un GPU c’est de séparer les 2 : on parle alors de kernel
y_new[i] = y_old[i] + alpha * x[i]
On utilise le « fragment pipeline » pour les calculs (= plusieurs unités en // ), il se
comporte comme un processeur vectoriel de la taille de notre texture !
Kernel => shader sur le GPU, c’est-à-dire un petit programme qui s’exécute sur
chaque fragment // shader for RGBA data
// and texture2D
uniform sampler2D textureY;
uniform sampler2D textureX;
uniform float alpha;
void main(void) {
vec4 y = exture2D(textureY,gl_TexCoord[0].st);
vec4 x = texture2D(textureXgl_TexCoord[0].st);
gl_FragColor = y + alpha*x;
}
7. Présentation du CEPC : GPGPU
Concept 3 : Computing = Drawing
On va maintenant mettre tous les éléments ensemble pour finir le calcul.
Si on récapitule :
• On a créé des textures avec nos données.
• On a créé des shaders avec nos algorithmes, à exécuter sur chaque fragment.
• On a établit un mapping 1:1 entre nos indices et les pixels.
Il ne reste plus qu‘ une (!) chose : généré une scène avec la « bonne géométrie »
pour que notre shader soit exécuté sur chaque élément de la texture !
Et c’est finalement très simple : un rectangle plein suffit !
En affichant un simple rectangle texturé, on exécute notre
kernel sur chaque élément de notre vecteur de départ !
8. Présentation du CEPC : GPGPU
Le Grand Public ;-)
Apple CoreImage / CoreVideo
Framework de développement Apple OSX
10.4…
Propose un fallback CPU si la carte ne le
permet pas.
Utilisé par QuartzExtreme et le Dashboard
Notion d’ImageUnits (kernel …)
Quartz Composer permet de jouer facilement
avec.
Apple Aperture, iMovie (CoreVideo), Motion
9. Présentation du CEPC : GPGPU
Base de Données
Les tris
GPUTeraSort, tri haute performance sur GPU
http://gamma.cs.unc.edu/GPUTERASORT/
Calcul rapide des opérations BDD
http://gamma.cs.unc.edu/DB/
Les jeux (!)
Oblivion & co …
Ils utilisent de plus en plus ces techniques
pour le rendu réaliste des scènes.
10. Présentation du CEPC : GPGPU
Traitement de Signal / Audio
FFT
• GPUFFTW : une FFT sur GPU en puissance de 2
http://gamma.cs.unc.edu/GPUFFTW/
DFT
• Jasper (implémentation GPU du JPEG 2000 )
http://www.cse.cuhk.edu.hk/~ttwong/software/dwtgpu/dwtgpu.html
Audio
• Bionicfx annonce AVEX ( http://www.bionicfx.com/ )
BionicFX announced a technology for music production that turns NVIDIA video
cards into audio effects processors. Audio Video Exchange (AVEX) converts
digital audio into graphics data, and then performs effect calculations
using the 3D architecture of the GPU. The latest video cards from NVIDIA
are capable of more than 40 gigaflops of processing power compared to less
than 6 gigaflops on Intel and AMD CPUs.
Réseau de Neurones
Améliore de 20 fois un système de détection de texte sur une ATI RADEON 9700
PRO.
Cryptographie
AES
Secret Key « Stream Cipher »
11. Présentation du CEPC : GPGPU
Conclusion
Ati et NVIDIA annonce des »GPU » dédié
Convergence des CPU/GPU
NVIDIA investit 2,93M$ dans Acceleware spécialiste canadien du GP-GPU
(programme CUDA )
Annoncée comme étant la « disruptive technology 2007 »par les analystes
Cluster de GPU (SLI, mais aussi réseau !)
12. Présentation du CEPC : GPGPU
Quelques Liens…
http://www.gpgpu.org/
http://shallows.sourceforge.net/
Brook : http://graphics.stanford.edu/projects/brookgpu/
Cg : http://www.nvidia.com/
Sh : http://libsh.org/
ATI : http://developper.ati.com/
NVIDIA : http://developper.nvidia.com/
Les Shaders et le GLSL :
• http://www.lighthouse3d.com/opengl/glsl/
• http://opengl.org/documentation/books.html#oglsl
Un tutorial facile : http://www.mathematik.uni-dortmund.de/~goeddeke/gpgpu/
Notes de l'éditeur
Input : description de la geometrie 1 er stage : transformation en “screen coordinate” 2eme stage : rasterization : 1 fragment per pixel location 3eme stage : compute color for fragment from texture information
Si on avait N processeurs on aurait un seul passage c’est le SIMD