comment gpu faire cela · 2011-11-28 · formation cira : « calcul intensif en rhône alpes »...

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 ?

Formation CIRA/GPU/2011 EQ 2/54Le 7 novembre 2011

Ce que cette présentationse sera pas/sera !

● Ce que ce ne sera pas :● Une présentation n°57005 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


Le Triptyque du projet

● Où en sommes-nous ?● Mais, d'abord, qui sommes-nous ?

● Où allons-nous ?● Mais de combien de temps nous disposons ?

● Comment y aller ?● Le pragmatisme comme premier principe

● Tout est histoire de contexte !


La difficulté du sujet « tendance »

A chaque combinaison de réponses, une solution !

Pourquoi ?Pourquoi ?Quoi ?Quoi ?Qui ?Qui ?

Quand ?Quand ?Combien ?Combien ?

Où ?Où ?Comment ?Comment ?


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 ?


1er au Top 500 : Tianhe 1Ala première vitrine du GPU

1/4 siècle auparavant

sur les écrans de cinéma

« The Last Starfighter »

● Quand : Novembre 2010● Où : Chine● Combien : 2.507 Pflops● Quoi : Linpack● Comment : CPU+GPU

● 7168 Nvidia Tesla C2050● 14336 CPU Xeon

● Qui : NUDT ● Le « DARPA » chinois)

● Pourquoi : ...


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 !

http://img.wallpaperstock.net:81/the-last-starfighter-wallpapers_16826_1024x768.png


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-MP4● 2011 : 11 min sur GTX 560 Ti● Performances : x1500● Prix : 1/150 000

● Si Unité Centrale : 1/15000

● Consommation : 1/25000● Si Unité Centrale : 1/5000


Pourquoi autant de puissance ?Une croissance très différente

● CPU : Passmark x20● 2001 : AMD Athlon XP 2000+ : 370 ● 2011 : Intel Xeon X5650 : 8000

● GPU : Shader operations vs Flops x2500● 2001 : 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 ?


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


Pourquoi autant de puissance :Rastérisation & calcul matriciel

● Modele 2 World : 3 produits matriciels● Rotation● Translation● Mise à l'échelle

● World 2 View : 2 produits matriciels● Position de la caméra● Direction de l'endroit pointé

● View 2 Projection

Un GPU : un « gros » multiplicateur de matrices

W2V

M2W

V2P


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 »


Pourquoi autant de puissance :une machine massivement...

● Vectorielle : SIMD (Simple Instruction Multiple Data)● Addition de deux positions (x,y,z) : 1 seule commande

● Parallèle : MIMD (Multiple Instructions Multiple Data)● 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


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


Quand ? Nvidia et sa carte C1060

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


Quand ?Quelques grandes étapes...

● 1992-01 : OpenGL et la naissance d'un standard● 1998-03 : OpenGL 1.2 et des fonctions intéressantes● 2002-12 : Cg Toolkit (Nvidia) et l'extension du langage

● Des Wrappers pour d'autres langages (Python)

● 2007-06 : CUDA (Nvidia) ou l'arrivée d'un vrai langage● 2008-06 : Snow Leopard (Apple) intégrant OpenCL

● La volonté d'utiliser au mieux sa machine ?

● 2008-11 : OpenCL 1.0 et ses premières spécifications● 2011-04 : WebCL et sa première version par Nokia


Quelle position ?Les Autres Accélérateurs...

● Accélérateurs : une vieille histoire de coprocesseur...● 1980 : 8087 (sur 8086/8088) pour calcul en virgule flottante● 1989: 80387 (sur 80386) et le respect de la IEEE 754● 1990 : 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 »


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, ...


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


Quoi ? Ou l'allégorie du « bateau » et le modèle « en couches »

Librairies

OS

GPUMatériel

CPU/RAM

LangagesC, Fortran

Python

Programmes

KernelsOpenCLCUDA

OpenCLCuda

ClAmd*

Pilote

Stagiaire DoctorantPost-doctorant

Ingénieur en CalculScientifique

Technicien & Ingénieur Systèmes & Réseaux

ChercheurEnseignant-Chercheur

PourQui !

ParQui !


Quoi ?Question de « hard » et de « soft »

● Toujours question de « hard » et de « soft »● Mais quelles différences ?

● 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, ...)● Évolution permanente : BLAS né 1979 avec 16+9 implémentations

● Méthodologie :● Entre conservatisme & modernité


Où ? Ou des domaines d'applications très divers

● Applications au calcul scientifique :● Visualisation scientifique (de gros volumes de données)

– Lié à OpenGL (forte intrication dans OpenCL)– OpenCV (pour acquisition & traitement temps réel)

● Traitement de données– Algèbre linéaire : CuBLAS, clAmdBlas, CuSparse , (CULA)– Analyse spectrale : CuFFT, clAmdFFT, PyFFT

● Simulation numérique :– Toutes les librairies !

● Des liens : http://gpuscience.com/

http://gpuscience.com/


Où ? Ou des domaines d'applications très divers

● Applications informatiques « générales »● Accélération AES (pour SSL)● Pare-feu (packet-shader) :

http://shader.kaist.edu/packetshader/io_engine/index.html● Base de données (2004) :

– http://gamma.cs.unc.edu/DB/● Tri rapide

– http://code.google.com/p/back40computing/wiki/RadixSorting● Craqueur de mot de passe :

– OclHashCat

http://gamma.cs.unc.edu/DB/


Environnements CUDA/OpenCL :3 acteurs Nvidia/AMD/(Intel)/Nokia

Composant Vers.Architecture Version Développeur Intégrateur

CPU GPU 32 64 Cuda OpenCL BLAS Sparse FFT RNG

Pilote Nvidia 280.5.9270.41.19

oui oui lib lib

Pilote ATI 11.9 oui oui

Cuda Toolkit 4.0.17 oui oui oui dev dev oui oui oui oui

AMD APP SDK 2.5 oui oui oui oui lib/dev

AMD APP ML 1.4.182 oui oui oui oui oui

Intel OpenCL 1.5 oui oui oui

PyCUDA 2011.1.2 oui oui oui

PyOpenCL 2011.1.2 oui oui oui oui oui

WebCL Nokia 1.0.2rc30 oui oui oui oui oui


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 270.41.19, mais le 285.05.09 !

● 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 !


Comment ?Petites remarques préalables...

● OS supportés : Linux, Windows, MacOS X● Linux : OK, MacOSX > 10.6.8, Windows : XP, Vista, 7

● 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é● 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


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


Comment par WebGL ?Son GPU à travers Firefox

● Le prérequis :● Une implémentation OpenCL sur sa machine

– Celle de Nvidia (avec pilote 285.05.09, pas le 270.41.19)– Celle de AMD/ATI (permettant d'utiliser le processeur)– Celle d'Intel (non, je plaisante !)

● Firefox 7 (en x86, pas x86_64)● Greffon Nokia : http://webcl.nokiaresearch.com/

● Aller sur : http://webcl.nokiaresearch.com/kerneltoy/● Petite démo ?


Comment par Python ?Son GPU à travers Python

● Le prérequis :● Une implémentation OpenCL ou Cuda sur sa machine

– Celle de Nvidia (avec pilote 285.05.09, pas le 270.41.19)– Celle de AMD/ATI (permettant d'utiliser le processeur)

● Librairies de développement OpenCL ou Cuda– Celle de Nvidia– Celle de AMD

● Python, Boost (pour la liaison au C), Compilateur C● PyCUDA ou PyOpenCL à télécharger

● Petite démo ?


Comment par C/C++ ?Son GPU avec AMD ou Nvidia

● Le prérequis :● Une implémentation OpenCL ou Cuda sur sa machine

– Celle de Nvidia (avec pilote 285.05.09, pas le 270.41.19)– Celle de AMD/ATI (permettant d'utiliser le processeur)

● Librairies de développement OpenCL ou Cuda– Celle de Nvidia– Celle de AMD

● Un compilateur C

● Petite démo ? Vous êtes sûr ? En OpenCL ?


Comment ?Un « Hello World » en OpenCL...

● Définir deux vecteurs en « Ascii »● Les dupliquer en deux gros vecteurs● Les ajouter avec un noyau OpenCL● Imprimer à l'écran le résultat (oui, c'est tout...)

Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World! Hello OpenCL World!

The End

Addition de 2 vecteurs a+b =c

pour tout n :c[n] = a[n] + b[n]


Comment ?« Hello World » OpenCL en C...

#include <stdio.h>

#include <stdlib.h>

#include <CL/cl.h>

const char* OpenCLSource[] = {

"__kernel void VectorAdd(__global int* c, __global int* a,__global int* b)",

"{",

" // 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",

" c[n] = a[n] + b[n];",

"}"

};

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

int main(int argc, char **argv)

{

int HostVector1[SIZE], HostVector2[SIZE];

for(int c = 0; c < SIZE; c++)

{

HostVector1[c] = InitialData1[c%20];

HostVector2[c] = InitialData2[c%20];

}

cl_platform_id cpPlatform;

clGetPlatformIDs(1, &cpPlatform, NULL);

cl_int ciErr1;

cl_device_id cdDevice;

ciErr1 = clGetDeviceIDs(cpPlatform, CL_DEVICE_TYPE_GPU, 1, &cdDevice, NULL);

cl_context GPUContext = clCreateContext(0, 1, &cdDevice, NULL, NULL, &ciErr1);

cl_command_queue cqCommandQueue = clCreateCommandQueue(GPUContext,

cdDevice, 0, NULL);

cl_mem GPUVector1 = clCreateBuffer(GPUContext, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,

sizeof(int) * SIZE, HostVector1, NULL);

cl_mem GPUVector2 = clCreateBuffer(GPUContext, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,

sizeof(int) * SIZE, HostVector2, NULL);

cl_mem GPUOutputVector = clCreateBuffer(GPUContext, CL_MEM_WRITE_ONLY,sizeof(int) * SIZE, NULL, NULL);

cl_program OpenCLProgram = clCreateProgramWithSource(GPUContext, 7, OpenCLSource,NULL, NULL);

clBuildProgram(OpenCLProgram, 0, NULL, NULL, NULL, NULL);

cl_kernel OpenCLVectorAdd = clCreateKernel(OpenCLProgram, "VectorAdd", NULL);

clSetKernelArg(OpenCLVectorAdd, 0, sizeof(cl_mem),(void*)&GPUOutputVector);

clSetKernelArg(OpenCLVectorAdd, 1, sizeof(cl_mem), (void*)&GPUVector1);

clSetKernelArg(OpenCLVectorAdd, 2, sizeof(cl_mem), (void*)&GPUVector2);

size_t WorkSize[1] = {SIZE}; // one dimensional Range

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);

clReleaseKernel(OpenCLVectorAdd);

clReleaseProgram(OpenCLProgram);

clReleaseCommandQueue(cqCommandQueue);

clReleaseContext(GPUContext);

clReleaseMemObject(GPUVector1);

clReleaseMemObject(GPUVector2);

clReleaseMemObject(GPUOutputVector);

for (int Rows = 0; Rows < (SIZE/20); Rows++) {

printf("\t");

for(int c = 0; c <20; c++) {

printf("%c",(char)HostOutputVector[Rows * 20 + c]);

}

}

printf("\n\nThe End\n\n");

return 0;

}

Nombre de LignesDe OpenCLOve

rkill

!

Appel Noyau

NoyauOpenCL


Comment ?« Hello World » OpenCL en Python

import pyopencl as cl

import numpy

import numpy.linalg as la

import sys

OpenCLSource = """

__kernel void VectorAdd(__global int* c, __global int* a,__global int* b)

{

// Index of the elements to add

unsigned int n = get_global_id(0);

// Sum the n th element of vectors a and b and store in c

c[n] = a[n] + b[n];

}

"""

InitialData1=[37,50,54,50,56,0,43,43,74,71,32,36,16,43,56,100,50,25,15,17]

InitialData2=[35,51,54,58,55,32,36,69,27,39,35,40,16,44,55,14,58,75,18,15]

SIZE=2048

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()

queue = cl.CommandQueue(ctx)

mf = cl.mem_flags

GPUVector1 = cl.Buffer(ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=HostVector1)

GPUVector2 = cl.Buffer(ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=HostVector2)

GPUOutputVector = cl.Buffer(ctx, mf.WRITE_ONLY, HostVector1.nbytes)

OpenCLProgram = cl.Program(ctx, OpenCLSource).build()

OpenCLProgram.VectorAdd(queue, HostVector1.shape, None,GPUOutputVector , GPUVector1, GPUVector2)

HostOutputVector = numpy.empty_like(HostVector1)

cl.enqueue_copy(queue, HostOutputVector, GPUOutputVector)

GPUVector1.release()

GPUVector2.release()

GPUOutputVector.release()

OutputString=''

for rows in range(SIZE/20):

OutputString+='\t'

for c in range(20):

OutputString+=chr(HostOutputVector[rows*20+c])

print OutputString

sys.stdout.write("\nThe End\n\n");


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 :

– Ouvrir le carton est plus difficile que de monter le meuble...– Exigence d'une API simplifiant l'appel d'OpenCL

● Pas de compatibilité entre les SDK de AMD et Nvidia– Chacun a développé son API : portabilité des codes difficile...

● Une solution, sinon « LA » solution : Python


Une « success story » pour finir ?Petite aventure au royaume d'Ising

● Un verre de spin complété aléatoirement de valeurs -1 ou 1

● Une intéraction simple basée sur les quatre voisins● 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 »

U

D

U

D

U

D D

D

U

UU

U

D

D

DD

U

U UU

D

4x4 256x256


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


Modèle d'Ising (en Python)Procédure principale

def MainLoop(sigma,J,T,iterations):

for p in range(0,iterations):

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]

● 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


Modèle d'Ising (en Python) :pour une température donnée T...

i=N³/4

i=N³/2i=3N³/4

i=N²

Final : i=N³

Initial : T=0.1

DuréeDurée

147sPortable

E6410Intel i7 M640

DuréeDurée

153s153sStationStation

Precision 7500Precision 75002 Intel X56502 Intel X5650


Modèle d'Ising (en Python) :Vers une température critique

T=0.8 T=1.6

T=4.0T=3.2T=2.4

T=0.1Initial

Energie=f(T)

Tc~2.3


Modèle d'Ising (en Python) :OpenCL version « globale »

#define znew (z=36969*(z&65535)+(z>>16))

#define wnew (w=18000*(w&65535)+(w>>16))

#define MWC ((znew<<16)+wnew )

#define MWCfp (MWC + 1.0f) * 2.328306435454494e-10f

__kernel void MainLoop(__global char *s,

float J,float T,uint size,uint iterations,

int seed_w,int seed_z)

{

int z=seed_z;

int w=seed_w;

for (uint i=0;i<iterations;i++) {

uint x=(uint)(MWCfp*sizex) ;

uint y=(uint)(MWCfp*sizey) ;

int p=s[x+size*y];

int d=s[x+size*((y+1)%size)];

int u=s[x+size*((y-1)%size)];

int l=s[((x-1)%size)+size*y];

int r=s[((x+1)%size)+size*y];

float DeltaE=2.0f*J*p*(u+d+l+r);

int factor=((DeltaE < 0.0f) ||

(MWCfp < exp(-DeltaE/T))) ? -1:1;

s[x%size+size*(y%size)] = factor*p;

barrier(CLK_GLOBAL_MEM_FENCE);

}

}

RNG MarsagliaMWC


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...


Modèle d'Ising (en Python)OpenCL version « locale »

RNG MarsagliaMWC

Synchronisation

Conditionsaux bords#define BSZ $block_size

/* Marsaglia RNG very simple implementation */

#define znew (z=36969*(z&65535)+(z>>16))

#define wnew (w=18000*(w&65535)+(w>>16))

// MWC is a signed one : between -2^31 to 2^31-1

#define MWC ((znew<<16)+wnew )

// MWCfp is a float one : between 0 and 1

#define MWCfp (float)((MWC + 2.147483648e9f) * 2.328306435454494e-10f)

__kernel void MainLoop(__global int *s,

__constant int *seed_w,

__constant int *seed_z,

float J,float T,uint size,uint iterations)

{

// Define global offset for each work items

uint base_idx=(uint)(BSZ*get_global_id(0));

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)];

int w=seed_w[(uint)(get_global_id(1))%get_global_size(1)];

// Main loop

for (uint i=0;i<iterations;i++)

{

// Version with MWCfp

int x=(uint)(MWCfp*BSZ)%BSZ;

int y=(uint)(MWCfp*BSZ)%BSZ;

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)];

int l= s[((base_idx+x-1)%size)+size*((base_idy+y)%size)];

int r= s[((base_idx+x+1)%size)+size*((base_idy+y)%size)];

float DeltaE=2.0f*J*p*(float)(u+d+l+r);

int factor= ((DeltaE < 0.0f) || (MWCfp < exp(-DeltaE/T))) ? -1:1;

s[base_idx+x+(base_idy+y)*size]= factor*p;


}



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...


GeForce GTX560Ti

NVS 3100M

GeForce GTX260

HD 5850

GeForce GT430

GeForce 8400GS

GeForce GT220

GeForce GT220

GeForce 8600MGT

HD 4850

HD 4890

Tesla C1060

Quadro 4000

0,00 200,00 400,00 600,00 800,00 1000,00 1200,00 1400,00

Réel Utilisateur Système

Durée en secondes

Typ

e de

GP

U

Modèle d'Ising (en Python/OpenCL)Différents GPU & version Locale

Intel Xeon [email protected]

Intel Core i7 [email protected]

Intel Core 2 Quad [email protected]

Intel Core 2Duo [email protected]

QEMU Virtual CPU version 0.12.5

Intel Core i5 [email protected]

Intel Pentium 4 3.00GHz

Intel Xeon [email protected]

Dual Core AMD Opteron 275

0,00 20,00 40,00 60,00 80,00 100,00 120,00 140,00 160,00


Durée en secondes

Pro

cess

eur

● Une GTX 560Ti écrase une Quadro 4000 !● Un processeur « virtuel » (Qemu de KVM) qui scale...

CPUGPUCa « scale » bien !

GPU portables...


Modèle d'Ising : et en Cuda ?

OpenCL vers Cuda● Les mêmes concepts● Des noms différents● (find/replace) suffit !

● En Python, moins d'1/2 j

GeForce GTX560Ti

NVS 3100M

GeForce GTX260

GeForce GT430

GeForce 8400GS

GeForce GT220

GeForce GT220

GeForce 8600MGT

Tesla C1060

Quadro 4000

0,00 100,00 200,00 300,00 400,00 500,00 600,00 700,00 800,00 900,00 1000,00


Durée en secondes

Typ

e de

GP

U N

vidi

a

● Quel passage de OpenCL vers Cuda ?

● Quelles performances pour Cuda ?


Modèle d'Ising :Cuda meilleur que OpenCL ?

Résultats ambigus● Pour la meilleure :

● OpenCL

● Puissantes anciennes● Cuda

● Peu puissantes :● Cuda

● Quadro :● Cuda

GeForce GTX560Ti

NVS 3100M

GeForce GTX260

GeForce GT430

GeForce 8400GS

GeForce GT220

GeForce GT220

GeForce 8600MGT

Tesla C1060

Quadro 4000

0 0,2 0,4 0,6 0,8 1 1,2 1,4 1,6 1,8 2

Réel

Type de GPU Nvidia

Rap

port

de

duré

es C

uda/

Nvi

dia


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


Retour aux personnesau-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)


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)...


Retour aux personnes« à la ligne de flottaison »

● Pour ceux du calcul scientifique qui programment : OSS● Des librairies en version GPU devenues courantes :

– « métier » comme OpenMM,

– « support » comme CuBLAS, APPAMD, Magma, CuFFT, CuSparse, ...

● Des langages :– 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)


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

– 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)

● Des outils pour y arriver :– 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 »


Trucs & Actuces

● En GPU comme en Inde, attention aux « castes »● Toujours « caster » ses variables en I/O et dans les noyaux

● Toujours évaluer la pertinence de l'usage float/double● 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


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...

– Des contraintes d'exploitation

– Des domaines d'application spécifiques

● Calculateur « analogique »– Un retour aux « phénomènes » physiques, mais lesquels ?

● Mais GPU devient GP GPU

(GP comme General Purpose, bientôt JeePU)


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

comment gpu faire cela · 2011-11-28 · formation cira : « calcul intensif en rhône alpes »...

Documents