Comment GPU faire cela?

Transcription

1 Formation CIRA : «Calcul Intensif en Rhône Alpes» Comment GPU faire cela? «La science, c'est ce que le père enseigne à son fils. La technologie, c'est ce que le fils enseigne à son papa.» Michel Serres (Interview du Monde) Les GPUs : de la technologie pour la science?

2 Ce que cette présentation se sera pas/sera! Ce que ce ne sera pas : Une présentation n sur la techno des GPU Une présentation ne vantant «que» les avantages Une présentation des différentes solutions commerciales Ce que ce sera : Une approche personnelle issue de deux ans de recul Une présentation «à grain» variable Un tour d'horizon des solutions existantes Un recueil de «trucs & astuces» Un exemple d'implémentation : le modèle d'ising en 2D 2/54

3 Le Triptyque du projet Où en sommes-nous? Où allons-nous? Mais de combien de temps nous disposons? Comment y aller? Mais, d'abord, qui sommes-nous? Le pragmatisme comme premier principe Tout est histoire de contexte! 3/54

4 La difficulté du sujet «tendance» A chaque combinaison de réponses, une solution! Pourquoi? Quoi? Qui? Comment? Où? Quand? Combien? 4/54

5 Quelle présentation? Fil directeur : les 7 questions «Back to Basics» : retour aux fondamentaux... Pourquoi? Ou pourquoi autant de puissance? Quand? Ou comment en est-on arrivé là? Quoi? Ou quels usages en attendre aujourd'hui? Qui? Ou quels sont les «acteurs» du domaine? Où? Ou quels domaines d'application? Combien? Ou quelle «métrologie» y associer? Comment? Ou comment l'aborder, en tirer avantage? 5/54

6 1er au Top 500 : Tianhe 1A la première vitrine du GPU Quand : Novembre 2010 Où : Chine Combien : Pflops Quoi : Linpack Comment : CPU+GPU 7168 Nvidia Tesla C CPU Xeon 1/4 siècle auparavant Qui : NUDT Le «DARPA» chinois) Pourquoi :... sur les écrans de cinéma «The Last Starfighter» 6/54

7 Pourquoi? Ou d'où vient une telle puissance de calcul... Un film de série B... Mais une arrivée fracassante de l'image de synthèse! 7/54

8 Pourquoi? Ou d'où vient une telle puissance de calcul... «The Last Starfighter» 27 minutes d'images 22.5e9 opérations/image Usage d'un Cray X-MP 1984 : 12 jours sur X-MP : 11 min sur GTX 560 Ti Performances : x1500 Prix : 1/ Consommation : 1/25000 Si Unité Centrale : 1/15000 Si Unité Centrale : 1/5000 8/54

9 Pourquoi autant de puissance? Une croissance très différente CPU : Passmark x : AMD Athlon XP : : Intel Xeon X5650 : 8000 GPU : Shader operations vs Flops x : GeForce FX 5200 ~1 Gops 2011 : GTX 590 ~2500 GFlops Croissance GPU >> Croissance CPU Près de 125x pour le processeur graphique Tout ça pour faire des «Starfighter» en temps réel? 9/54

10 Pourquoi autant de puissance? Pour construire une scène 3D! 2 approches : Le «lancer de rayons» : PovRay La «rastérisation» : 3 opérations Lancer de rayons Partir de l'œil et se déplacer vers les «objets» de la scène Rastérisation : Model2World : on place des objets vectoriels dans l'espace World2View : on projète les objets sur un plan de vue View2Projection : on transforme le plan de vue en points 10/54

11 Pourquoi autant de puissance : Rastérisation & calcul matriciel Modele 2 World : 3 produits matriciels Rotation Translation Mise à l'échelle M2W W2V World 2 View : 2 produits matriciels Position de la caméra Direction de l'endroit pointé V2P View 2 Projection Un GPU : un «gros» multiplicateur de matrices 11/54

12 Pourquoi autant de puissance? Un retour au «généralisme» Dans les GPU Des processeurs dédiés Efficacité = enchaînement Mais perte d'adaptation Scènes changeantes Détails différents La Solution Disposer de processeurs plus «généralistes» 12/54

13 Pourquoi autant de puissance : une machine massivement... Vectorielle : SIMD (Simple Instruction Multiple Data) Parallèle : MIMD (Multiple Instructions Multiple Data) Addition de deux positions (x,y,z) : 1 seule commande Plusieurs programmes en parallèle des mêmes données En fait, SIMT : Simple Instruction Multiple Threads Les cœurs de calcul se répartissent les Threads Chaque cœur peut travailler indépendamment des autres Nécessité de synchroniser les Threads 13/54

14 Combien? Ou lorsque le «budget» devient un sujet La puissance : «avec 200, t'as...» «selon les fabricants» 1262 Gflops32... «selon les testeurs» 512 Gflops32 (SGEMM) Et «seulement» 100 Gflops64 (DGEMM)! La consommation : «avec 200 et 170W, t'as...» : 3 Gflops32/W et 0.6 Gflops64/W (sans l'uc ) Les trois coûts du logiciel : (essentiellement humain!) D'entrée : appropriation de la technologie D'exploitation : maintien en fonctionnement De sortie : migration vers une architecture différente 14/54

15 Quand? Nvidia et sa carte C1060 «Nvidia Launches Tesla Personal Supercomputer» Quand : le 19/11/2008 Où : sur Tom's Hardware Quoi : une carte C1060 PCIe avec 240 coeurs Combien : 933 Gflops SP (mais 78 Gflops DP) Qui : Nvidia 15/54

16 Quand? Quelques grandes étapes : OpenGL et la naissance d'un standard : OpenGL 1.2 et des fonctions intéressantes : Cg Toolkit (Nvidia) et l'extension du langage Des Wrappers pour d'autres langages (Python) : CUDA (Nvidia) ou l'arrivée d'un vrai langage : Snow Leopard (Apple) intégrant OpenCL La volonté d'utiliser au mieux sa machine? : OpenCL 1.0 et ses premières spécifications : WebCL et sa première version par Nokia 16/54

17 Quelle position? Les Autres Accélérateurs... Accélérateurs : une vieille histoire de coprocesseur : 8087 (sur 8086/8088) pour calcul en virgule flottante 1989: (sur 80386) et le respect de la IEEE : 80486DX avec l'intégration du FPU dans le CPU 1997 : K6-3DNow! & Pentium MMX : le SIMD dans le CPU 1999 : fonction SSE et le début d'une longue série (SSE4) Quand les puces ressortent du CPU 1998 : les DSP style TMS320C67x comme outils 2008: Cell dans la PS3, IBM dans le Road Runner et Top1 Affaire de compilateurs & Programmation «fine» 17/54

18 Qui : pour qui et par qui? Ou quels sont les acteurs... Chercheurs/Enseignant-chercheurs Stagiaires/Doctorants/Post-doctorants Ingénieurs en calcul scientifique Ingénieurs systèmes & réseaux Éditeurs : Nvidia, AMD, (Intel), Nokia, (Apple), (Samsung) Open Source Teams Fabricants de matériels : Nvidia, AMD/ATI, Intel Intégrateurs : Dell, HP,... 18/54

19 Quoi? Ou des domaines d'application très différents Codes EXE : exécutable fournis par l'éditeur À exécuter sous contraintes (matériel, architecture, OS, librairies, etc...) Codes SRC : code source fourni par l'éditeur À compiler sous contraintes (architecture, compilateur, librairies) À exécuter sous contraintes Codes OSS : Open Source Software À modifier : tou(te)s architectures, compilateurs, librairies À fiabiliser/consolider/pérenniser/étendre/valoriser Codes CFS : Code «From Scratch» À concevoir/développer À fiabiliser/consolider/pérenniser/étendre/valoriser 19/54

20 Quoi? Ou l'allégorie du «bateau» et le modèle «en couches» Programmes Chercheur Enseignant-Chercheur Pour Qui! Stagiaire Doctorant Post-doctorant Ingénieur en Calcul Scientifique Par Qui! Technicien & Ingénieur Systèmes & Réseaux Kernels OpenCL CUDA Langages C, Fortran Python OpenCL Cuda ClAmd* Librairies Pilote OS GPU Matériel CPU/RAM 20/54

21 Quoi? Question de «hard» et de «soft» Toujours question de «hard» et de «soft» Outils «métier» : durée de vie longue! Abinit 25 ans, Blast 21 ans, Lammps 7 ans, BigDFT 6 ans Gaussian 41 ans, Molcas 22 ans, Vasp 20 ans Matériels : durée de vie courte! Le GPGPU a 4 ans, le Cell a vécu 5 ans, Larrebee mort né, MIC? Logiciels (OS, librairies, compilateurs, intergiciels,...) Mais quelles différences? Évolution permanente : BLAS né 1979 avec 16+9 implémentations Méthodologie : Entre conservatisme & modernité 21/54

22 Où? Ou des domaines d'applications très divers Applications au calcul scientifique : Visualisation scientifique (de gros volumes de données) Traitement de données Algèbre linéaire : CuBLAS, clamdblas, CuSparse, (CULA) Analyse spectrale : CuFFT, clamdfft, PyFFT Simulation numérique : Lié à OpenGL (forte intrication dans OpenCL) OpenCV (pour acquisition & traitement temps réel) Toutes les librairies! Des liens : 22/54

23 Où? Ou des domaines d'applications très divers Applications informatiques «générales» Accélération AES (pour SSL) Pare-feu (packet-shader) : Base de données (2004) : Tri rapide Craqueur de mot de passe : OclHashCat 23/54

24 Environnements CUDA/OpenCL : 3 acteurs Nvidia/AMD/(Intel)/Nokia Composant Pilote Nvidia Pilote ATI Cuda Toolkit Architecture Version CPU 32 Développeur Vers. GPU oui oui Cuda OpenCL BLAS Sparse lib lib dev dev FFT RNG oui oui oui oui oui oui oui oui oui oui oui oui AMD APP SDK 2.5 AMD APP ML Intel OpenCL 1.5 PyCUDA PyOpenCL oui oui oui oui oui WebCL Nokia 1.0.2rc30 oui oui oui oui oui Intégrateur oui oui oui oui lib/dev oui oui oui oui oui oui oui oui 24/54

25 Comment? Installation de base 3 Implémentations OpenCL : Nvidia (+Cuda), AMD, Intel Ce qu'il faut (avoir) : (pas nécessaire pour AMD et Intel) Une carte graphique compatible Un pilote propriétaire compatible avec son OS OpenCL 1.1 sur Nvidia, pas le pilote , mais le ! Ce qu'il faut (faire) : Installer le pilote propriétaire (dispensé pour OpenCL/CPU) Installer les librairies Installer le SDK pour lancer les exemples Ce qu'il faut (en penser) : à vous de voir! 25/54

26 Comment? Petites remarques préalables... OS supportés : Linux, Windows, MacOS X Nvidia : double précision réservé aux «puissantes» Les peu puissantes généralement non (portables, etc...) Les plus puissantes oui (au dessus de la GTX 260) ATI : double précision bizarrement implémenté Linux : OK, MacOSX > , Windows : XP, Vista, 7 Une 4350 à 23 oui, une 6870 à 150 non, une 5850 oui Des calculs GPU distants Nvidia : no problemo ATI : «bricolage» du GDM et «ssh -x» indispensables 26/54

27 Comment? Premier contact... Approche «perturbative» Examiner les exemples des SDK (en C/C++) et les modifier Problèmes : pas compatibles entre eux en OpenCL Approche «constructive» : Python pour GPU Installer les PyOpenCL et PyCuda Prendre un problème très simple en Python et le transcrire Approche «positive» : WebCL Installer Firefox 7 (32 bits) et le greffon Nokia Aller sur le «WebCL Kernel Toy» et jouer avec Len(n)a 27/54

28 Comment par WebGL? Son GPU à travers Firefox Le prérequis : Une implémentation OpenCL sur sa machine Celle de Nvidia (avec pilote , pas le ) Celle de AMD/ATI (permettant d'utiliser le processeur) Celle d'intel (non, je plaisante!) Firefox 7 (en x86, pas x86_64) Greffon Nokia : Aller sur : Petite démo? 28/54

29 Comment par Python? Son GPU à travers Python Le prérequis : Une implémentation OpenCL ou Cuda sur sa machine Librairies de développement OpenCL ou Cuda Celle de Nvidia (avec pilote , pas le ) Celle de AMD/ATI (permettant d'utiliser le processeur) Celle de Nvidia Celle de AMD Python, Boost (pour la liaison au C), Compilateur C PyCUDA ou PyOpenCL à télécharger Petite démo? 29/54

30 Comment par C/C++? Son GPU avec AMD ou Nvidia Le prérequis : Une implémentation OpenCL ou Cuda sur sa machine Librairies de développement OpenCL ou Cuda Celle de Nvidia (avec pilote , pas le ) Celle de AMD/ATI (permettant d'utiliser le processeur) Celle de Nvidia Celle de AMD Un compilateur C Petite démo? Vous êtes sûr? En OpenCL? 30/54

31 Comment? Un «Hello World» en OpenCL... Addition de Les dupliquer en deux gros vecteurs 2 vecteurs a+b =c pour tout n : Les ajouter avec un noyau OpenCL c[n] = a[n] + b[n] Imprimer à l'écran le résultat (oui, c'est tout...) Définir deux vecteurs en «Ascii» The End 31/54

32 Comment? «Hello World» OpenCL en C... #include <stdio.h> cl_mem GPUVector1 = clcreatebuffer(gpucontext, CL_MEM_READ_ONLY CL_MEM_COPY_HOST_PTR, #include <stdlib.h> sizeof(int) * SIZE, HostVector1, NULL); #include <CL/cl.h> cl_mem GPUVector2 = clcreatebuffer(gpucontext, CL_MEM_READ_ONLY CL_MEM_COPY_HOST_PTR, " kernel void VectorAdd( global int* c, global int* a, global int* b)", "{", sizeof(int) * SIZE, HostVector2, NULL);! const char* OpenCLSource[] = { cl_mem GPUOutputVector = clcreatebuffer(gpucontext, CL_MEM_WRITE_ONLY,sizeof(int) * SIZE, NULL, NULL); cl_program OpenCLProgram = clcreateprogramwithsource(gpucontext, 7, OpenCLSource,NULL, NULL); " // Index of the elements to add \n", " unsigned int n = get_global_id(0);", " // Sum the n th element of vectors a and b and store in c \n", clsetkernelarg(openclvectoradd, 0, sizeof(cl_mem),(void*)&gpuoutputvector); " c[n] = a[n] + b[n];", clsetkernelarg(openclvectoradd, 1, sizeof(cl_mem), (void*)&gpuvector1); ve rk ill clbuildprogram(openclprogram, 0, NULL, NULL, NULL, NULL); cl_kernel OpenCLVectorAdd = clcreatekernel(openclprogram, "VectorAdd", NULL); clsetkernelarg(openclvectoradd, 2, sizeof(cl_mem), (void*)&gpuvector2); "}" size_t WorkSize[1] = {SIZE}; // one dimensional Range }; int InitialData1[20] = {37,50,54,50,56,0,43,43,74,71,32,36,16,43,56,100,50,25,15,17}; int InitialData2[20] = {35,51,54,58,55,32,36,69,27,39,35,40,16,44,55,14,58,75,18,15}; #define SIZE 2048 clenqueuendrangekernel(cqcommandqueue, OpenCLVectorAdd, 1, NULL, WorkSize, NULL, 0, NULL, NULL); int HostOutputVector[SIZE]; clenqueuereadbuffer(cqcommandqueue, GPUOutputVector, CL_TRUE, 0,SIZE * sizeof(int), HostOutputVector, 0, NULL, NULL); int main(int argc, char **argv) clreleasekernel(openclvectoradd); { int HostVector1[SIZE], HostVector2[SIZE]; for(int c = 0; c < SIZE; c++) O HostVector1[c] = InitialData1[c%20]; HostVector2[c] = InitialData2[c%20]; cl_platform_id cpplatform; clreleasecommandqueue(cqcommandqueue); clreleasecontext(gpucontext); { } clreleaseprogram(openclprogram); clgetplatformids(1, &cpplatform, NULL); clreleasememobject(gpuvector1); clreleasememobject(gpuvector2); clreleasememobject(gpuoutputvector); Noyau OpenCL for (int Rows = 0; Rows < (SIZE/20); Rows++) { printf("\t"); for(int c = 0; c <20; c++) { printf("%c",(char)hostoutputvector[rows * 20 + c]); cl_int cierr1; } cl_device_id cddevice; } cierr1 = clgetdeviceids(cpplatform, CL_DEVICE_TYPE_GPU, 1, &cddevice, NULL); printf("\n\nthe End\n\n"); cl_context GPUContext = clcreatecontext(0, 1, &cddevice, NULL, NULL, &cierr1); cl_command_queue cqcommandqueue = clcreatecommandqueue(gpucontext, Nombre de Lignes De OpenCL return 0; Appel Noyau } cddevice, 0, NULL); 32/54

33 Comment? «Hello World» OpenCL en Python import pyopencl as cl mf = cl.mem_flags import numpy GPUVector1 = cl.buffer(ctx, mf.read_only mf.copy_host_ptr, hostbuf=hostvector1) import numpy.linalg as la import sys OpenCLSource = """ GPUVector2 = cl.buffer(ctx, mf.read_only mf.copy_host_ptr, hostbuf=hostvector2) kernel void VectorAdd( global int* c, global int* a, global int* b) GPUOutputVector = cl.buffer(ctx, mf.write_only, HostVector1.nbytes) { OpenCLProgram = cl.program(ctx, OpenCLSource).build() // Index of the elements to add unsigned int n = get_global_id(0); OpenCLProgram.VectorAdd(queue, HostVector1.shape, None,GPUOutputVector, GPUVector1, GPUVector2) // Sum the n th element of vectors a and b and store in c HostOutputVector = numpy.empty_like(hostvector1) c[n] = a[n] + b[n]; cl.enqueue_copy(queue, HostOutputVector, GPUOutputVector) } GPUVector1.release() """ GPUVector2.release() InitialData1=[37,50,54,50,56,0,43,43,74,71,32,36,16,43,56,100,50,25,15,17] GPUOutputVector.release() InitialData2=[35,51,54,58,55,32,36,69,27,39,35,40,16,44,55,14,58,75,18,15] OutputString='' SIZE=2048 for rows in range(size/20): HostVector1=numpy.zeros(SIZE).astype(numpy.int32) HostVector2=numpy.zeros(SIZE).astype(numpy.int32) for c in range(size): HostVector1[c] = InitialData1[c%20] HostVector2[c] = InitialData2[c%20] ctx = cl.create_some_context() OutputString+='\t' for c in range(20): OutputString+=chr(HostOutputVector[rows*20+c]) print OutputString sys.stdout.write("\nthe End\n\n"); queue = cl.commandqueue(ctx) 33/54

34 Comment? «Hello World» OpenCL : la pesée Sur l'implémentation OpenCL précédente : En C : 75 lignes, 262 mots, 2848 octets En Python : 51 lignes, 137 mots, 1551 octets Facteurs : 0.68, 0.52, 0.54 en lignes, mots et caractères... Programmation OpenCL : Contexte de programmation difficile : Pas de compatibilité entre les SDK de AMD et Nvidia Ouvrir le carton est plus difficile que de monter le meuble... Exigence d'une API simplifiant l'appel d'opencl Chacun a développé son API : portabilité des codes difficile... Une solution, sinon «LA» solution : Python 34/54

35 Une «success story» pour finir? Petite aventure au royaume d'ising Un verre de spin complété aléatoirement de valeurs -1 ou 1 D U D U 4x4 U U U D D U D D U D D U U D D 256x256 Une intéraction simple basée sur les quatre voisins U LocalEnergy=2*J*s(x,y)*[s(x-1,y)+s(x-1,y)+s(x,y-1)+s(x,y+1)] Une règle simple de retournement (1-1 or -1 1) de site : 1) Si LocalEnergy est négative : convertie par ses voisins Loi des «moutons de Panurge» 2) Si RNG + petit que le facteur de Boltzmann (@ LocalEnergy and T ) Loi de «l'esprit bien français» 35/54

36 Le modèle d'ising en équations : Implémentation «naïve» Fonction Metropolis : Metropolis(sigma,J,T,step,iterations) sigma : verre de spin J : facteur de couplage (égal à l'unité pour les simulations) T : Température d'exploration Step : itérations entre 2 étapes (pour sauver un état) Iterations : nombre total d'explorations aléatoire du verre Température d'exploration : de 0.1 à 5 avec un pas de0.1 Sortie : Energie : basée sur l'estimation de l'intéraction de couplage ImageDeSortie : verre de Spin après itérations 36/54

37 Modèle d'ising (en Python) Procédure principale def MainLoop(sigma,J,T,iterations): for p in range(0,iterations): Appels RNG Coordonnées X,Y Entre 0 et 1 Conditions aux bords «univers cylindrique» Interaction des Spins Estimation de l'énergie Facteur de Boltzmann Appel Random & test X=numpy.random.randint(SIZE), Y=numpy.random.randint(SIZE) DeltaE=2.*J*sigma[X,Y]*( sigma[x,(y+1)%size]+ sigma[x,(y-1)%size]+ sigma[(x-1)%size,y]+ sigma[(x+1)%size,y]) if DeltaE < 0. or random() < exp(-deltae/t): sigma[x,y]=-sigma[x,y] 37/54

38 Modèle d'ising (en Python) : pour une température donnée T... Durée 147s Portable E6410 Intel i7 M640 Initial : T=0.1 i=n² i=n³/4 Durée 153s Station Precision Intel X5650 Final : i=n³ i=3n³/4 i=n³/2 38/54

39 Modèle d'ising (en Python) : Vers une température critique Initial Energie=f(T) Tc~2.3 T=0.1 T=2.4 T=0.8 T=3.2 T=1.6 T=4.0 39/54

40 Modèle d'ising (en Python) : OpenCL version «globale» for (uint i=0;i<iterations;i++) { #define znew (z=36969*(z&65535)+(z>>16)) uint x=(uint)(mwcfp*sizex) ; #define wnew (w=18000*(w&65535)+(w>>16)) uint y=(uint)(mwcfp*sizey) ; #define MWC ((znew<<16)+wnew ) int p=s[x+size*y]; #define MWCfp (MWC + 1.0f) * e-10f int d=s[x+size*((y+1)%size)]; kernel void MainLoop( global char *s, int u=s[x+size*((y-1)%size)]; int l=s[((x-1)%size)+size*y]; float J,float T,uint size,uint iterations, int seed_w,int seed_z) { int r=s[((x+1)%size)+size*y]; float DeltaE=2.0f*J*p*(u+d+l+r); RNG Marsaglia MWC int factor=((deltae < 0.0f) (MWCfp < int z=seed_z; exp(-deltae/t)))? -1:1; s[x%size+size*(y%size)] = factor*p; int w=seed_w; barrier(clk_global_mem_fence); } } 40/54

41 Modèle d'ising (en Python) Simulation finale Pour une verre de spin de 256x256 Pour 51 températures (de 0.1 à 5 par pas de 0.1) Pour 256x256x256 itérations En Python (bestial!) : 126 min (150 sec/t ) En Python et OpenCL «global» : 23 min (26 sec/t ) Et en C (classique) : 2 min 7 sec Il va falloir trouver autre chose! Segmenter le verre de spin en sous domaines... 41/54

42 Modèle d'ising (en Python) OpenCL version «locale» #define BSZ $block_size // Main loop /* Marsaglia RNG very simple implementation */ for (uint i=0;i<iterations;i++) #define znew (z=36969*(z&65535)+(z>>16)) { #define wnew (w=18000*(w&65535)+(w>>16)) // Version with MWCfp // MWC is a signed one : between -2^31 to 2^31-1 int x=(uint)(mwcfp*bsz)%bsz; #define MWC ((znew<<16)+wnew ) int y=(uint)(mwcfp*bsz)%bsz; // MWCfp is a float one : between 0 and 1 #define MWCfp (float)((mwc e9f) * e-10f) kernel void MainLoop( global int *s, int p=s[((base_idx+x)%size)+size*((base_idy+y)%size)]; int u= s[((base_idx+x)%size)+size*((base_idy+y-1)%size)]; int d= s[((base_idx+x)%size)+size*((base_idy+y+1)%size)]; constant int *seed_w, int l= s[((base_idx+x-1)%size)+size*((base_idy+y)%size)]; constant int *seed_z, int r= s[((base_idx+x+1)%size)+size*((base_idy+y)%size)]; float J,float T,uint size,uint iterations) float DeltaE=2.0f*J*p*(float)(u+d+l+r); { int factor= ((DeltaE < 0.0f) (MWCfp < exp(-deltae/t)))? -1:1; // Define global offset for each work items s[base_idx+x+(base_idy+y)*size]= factor*p; uint base_idx=(uint)(bsz*get_global_id(0)); barrier(clk_global_mem_fence); uint base_idy=(uint)(bsz*get_global_id(1)); // Assign eath work item a random defined seed provided by host int z=seed_z[(uint)(get_global_id(0))%get_global_size(0)]; } barrier(clk_global_mem_fence); int w=seed_w[(uint)(get_global_id(1))%get_global_size(1)]; RNG Marsaglia MWC Conditions aux bords Synchronisation 42/54

43 Modèle d'ising (en Python/OpenCL) Résultats version «Locale» Petits rappels : En Python pur : 126 minutes En C : 2 minutes (Gcc) et 1 minute (Icc) En Python OpenCL «Global» : 23 minutes Sur la même machine : Precision 7500 Avec l'appel sur la carte graphique : 46 secondes Avec l'appel des processeurs : 8 secondes... Moralité : OpenCL est sacrément puissant (en CPU) Prévisible? Oui! Des synchronisations entre tâches à tous moments... 43/54

44 Modèle d'ising (en Python/OpenCL) Différents GPU & version Locale Une GTX 560Ti écrase une Quadro 4000! Un processeur «virtuel» (Qemu de KVM) qui scale... Quadro 4000 Dual Core AMD Opteron 275 Tesla C1060 GPU portables... HD 4890 Intel Xeon HD 4850 Intel Pentium GHz Intel Core i5 750@2.67GHz GeForce GT220 Processeur Type de GPU GeForce 8600MGT GeForce GT220 GeForce 8400GS QEMU Virtual CPU version Intel Core 2Duo T8300@2.40GHz GeForce GT430 HD 5850 Intel Core 2 Quad Q8300@2.50GHz GeForce GTX260 GPU NVS 3100M GeForce GTX560Ti 0,00 200,00 400,00 600,00 800,00 Durée en secondes Réel Utilisateur Système 1000, ,00 Intel Core i7 M640@2.80GHz CPU Intel Xeon W3565@3.20GHz 1400,00 0,00 Ca «scale» bien! 40,00 60,00 80,00 100,00 120,00 140,00 160,00 Durée en secondes Réel 20,00 Utilisateur Système 44/54

45 Modèle d'ising : et en Cuda? Quel passage de OpenCL vers Cuda? Quelles performances pour Cuda? Quadro 4000 OpenCL vers Cuda Les mêmes concepts Des noms différents (find/replace) suffit! En Python, moins d'1/2 j GeForce 8600MGT GeForce GT220 Type de GPU Nvidia Tesla C1060 GeForce GT220 GeForce 8400GS GeForce GT430 GeForce GTX260 NVS 3100M GeForce GTX560Ti 0,00 100,00 200,00 300,00 400,00 500,00 600,00 700,00 800,00 900, ,00 Durée en secondes Réel Utilisateur Système 45/54

46 Modèle d'ising : Cuda meilleur que OpenCL? Résultats ambigus Quadro 4000 Pour la meilleure : Tesla C1060 Puissantes anciennes Cuda Peu puissantes : OpenCL Cuda Quadro : Rapport de durées Cuda/Nvidia GeForce 8600MGT GeForce GT220 GeForce GT220 GeForce 8400GS GeForce GT430 GeForce GTX260 NVS 3100M GeForce GTX560Ti 0 Cuda 0,2 0,4 0,6 0,8 1 1,2 1,4 1,6 1,8 2 Type de GPU Nvidia Réel 46/54

47 Modèle d'ising : et les résultats? Un processus aléatoire Une bonne superposition Les + et puissants Des résultats cohérents Une Tc ~ 2,3 47/54

48 Retour aux personnes au-dessus de la ligne de flottaison Pour les utilisateurs finaux de codes : EXE Des versions GPU se développent (tout comme les tarifs) ACEMD, Charmm, Gamess Un «marché» dopé par la mode Conseils : disposer de quelques éléments un jeu de tests pertinent et portable (référence) plusieurs architectures matérielles (Carte vidéo) plusieurs implémentations logicielles (OS, pilote) 48/54

49 Retour aux personnes «sur la ligne de flottaison» Pour ceux du calcul scientifique qui compilent : SRC «Free as a beer» : VMD, NAMD,... «Free as an idea» : Gromacs, BigDFT, Lammps,... Des librairies «métier» : OpenMM, PetSC Des librairies «support» : CuBLAS, CuFFT, AMDAPP, Magma, Conseils : disposer de quelques éléments Un jeu de tests pertinent et portable (référence) Plusieurs environnements de développement (compilateurs) Plusieurs implémentations logicielles (OS, pilote) Plusieurs architectures matérielles (Carte vidéo) Avoir une approche «intégrative» Rester pragmatique (se fixer des objectifs raisonnables)... 49/54

50 Retour aux personnes «à la ligne de flottaison» Pour ceux du calcul scientifique qui programment : OSS Des librairies en version GPU devenues courantes : Des langages : «métier» comme OpenMM, «support» comme CuBLAS, APPAMD, Magma, CuFFT, CuSparse,... CUDA chez Nvidia OpenCL chez Nvidia, AMD et Intel Conseils : Disposer de jeux de tests pertinents Avoir une approche «intégrative ascendante» initiale Utiliser systématiquement les directives Analyser son code par des «profileurs» (gprof, Valgrind) 50/54

51 Retour aux personnes «sous la ligne de flottaison» Pour ceux qui démarrent de 0 : le «From Scratch» Le retour d'un cadre : la localité CPU/mémoire Des outils pour y arriver : Il y a longtemps : tout à plat (un cœur, une mémoire) Il y a peu de temps : plusieurs (cœurs nœuds) : OpenMP, MPI Maintenant : connaître l'architecture (plusieurs cœurs ou RAM) WebCL pour appréhender les concepts du langage Python OpenCL ou Cuda pour travailler sur les noyaux Par4all et son «transformateur» de boucles pour le «générique» Conseils : Programmation plutôt «agile» 51/54

52 Trucs & Actuces En GPU comme en Inde, attention aux «castes» Toujours évaluer la pertinence de l'usage float/double Toujours «caster» ses variables en I/O et dans les noyaux Parfois, 32 bits suffisent amplement! Le calcul scientifique, c'est de la «cuisine»! La cuisine : le GPU, ses processeurs et sa mémoire privée Plan de travail : mémoire locale, rapide et limitée Placards : mémoire globale, «lente» (et aussi limitée)... et utiliser le tout de la manière la plus efficace 52/54

53 Retour sur le précédent épilogue 3 activités du calcul scientifique et quelle utilisation des GPU? Visualisation : un acteur incontournable Traitement de données : une alternative aux DSP Simulation numérique : une utilisation sous haute surveillance Et si finalement le GPU n'était qu'un Calculateur spécialisé, avec une puissance colossale, mais... Calculateur «analogique» Des contraintes d'exploitation Des domaines d'application spécifiques Un retour aux «phénomènes» physiques, mais lesquels? Mais GPU devient GP GPU (GP comme General Purpose, bientôt JeePU) 53/54

54 Conclusion Des bonnes pratiques Du code «générique» des librairies éprouvées pour pérenniser l'ensemble des directives pour permettre de rajouter d'autres technologies Des tests (permanents, et ce n'est pas plus mal!) Une période charnière passée (pour OpenCL)? OUI! De 2 à 5 acteurs (AMD, Nvidia, Intel, Nokia, Samsung) Un développement pour le Web (WebCL) Une généralisation de son usage dans les smartphones 54/54