Calcul Haute Performance et Parallélisme Historique et exemples

Transcription

1 Calcul Haute Performance et Parallélisme Historique et exemples Emmanuel Hermellin LIRMM Janvier 2014

2 Sommaire 1 Le Calcul Haute Performance Naissance des super-calculateurs Évolution des super-calculateurs Puissance de calcul et loi de Moore Utilisation et conception des super-calculateurs 2 Le Parallélisme Les différents types de parallélismes Les lois du parallélismes 3 La Programmation L optimisation du code source La programmation sous CPU La programmation sous GPU 2 / 63

3 Introduction Expression du besoin Dans pratiquement tous les domaines (recherche, ingénierie, entrepreneuriat, industrie,... ) on constate que le calcul intensif numérique prend une place essentielle afin de demeurer dans la compétition mondiale! Simulation numérique L émergence des très grands calculateurs a ouvert une nouvelle approche, la simulation numérique. La simulation permet d approcher des phénomènes complexes. 3 / 63

4 1 Le Calcul Haute Performance Naissance des super-calculateurs Évolution des super-calculateurs Puissance de calcul et loi de Moore Utilisation et conception des super-calculateurs 2 Le Parallélisme Les différents types de parallélismes Les lois du parallélismes 3 La Programmation L optimisation du code source La programmation sous CPU La programmation sous GPU Le Calcul Haute Performance 4 / 63

5 Définition Le Calcul Haute Performance La science relative à la conception et au développement des grands centres de calculs se nomme : Calcul Haute Performance (High Performance Computing) Le Calcul Haute Performance 5 / 63

6 1 Le Calcul Haute Performance Naissance des super-calculateurs Évolution des super-calculateurs Puissance de calcul et loi de Moore Utilisation et conception des super-calculateurs 2 Le Parallélisme Les différents types de parallélismes Les lois du parallélismes 3 La Programmation L optimisation du code source La programmation sous CPU La programmation sous GPU Le Calcul Haute Performance Naissance des super-calculateurs 6 / 63

7 L ENIAC Les découvertes Presper Eckert et John William Mauchly Electronic Numerical Integrator and Computer Ordinateur capable de faire des calculs balistiques 30 tonnes, 72 m2, 160 kw, 100 khz, 20 calculateurs, additions ou 357 multiplications par seconde. L architecture de Von Neumann Architecture en 4 parties utilisant une structure de stockage unique pour conserver les instructions et les données : L unité arithmétique et logique L unité de contrôle La mémoire volatile et permanente Les dispositifs d entrée et sortie Le Calcul Haute Performance Naissance des super-calculateurs 7 / 63

8 Les découvertes L architecture de Von Neumann est encore utilisée dans la quasi totalité de nos ordinateurs actuels Le Calcul Haute Performance Naissance des super-calculateurs 8 / 63

9 1 Le Calcul Haute Performance Naissance des super-calculateurs Évolution des super-calculateurs Puissance de calcul et loi de Moore Utilisation et conception des super-calculateurs 2 Le Parallélisme Les différents types de parallélismes Les lois du parallélismes 3 La Programmation L optimisation du code source La programmation sous CPU La programmation sous GPU Le Calcul Haute Performance Évolution des super-calculateurs 9 / 63

10 De 1960 à 1990 Historique 1960 apparition des premiers super-calculateurs commerciaux conçus par Seymour Cray pour la société Control Data Corporation. Control Data Corporation restera le premier constructeur mondial jusque dans les années A cette époque, Seymour Cray monte sa propre entreprise Cray Search. Il devient le leader des super-ordinateurs jusque dans les années Pendant cette période NEC, Intel, IBM sont déjà des multinationales puissantes et innovantes qui mettent sur le marché des machines compétitives. Le Calcul Haute Performance Évolution des super-calculateurs 10 / 63

11 De nos jours De nos jours, voici la distribution des constructeurs de super-calculateurs. Le Calcul Haute Performance Évolution des super-calculateurs 11 / 63

12 Évolution des processeurs Les processeurs au cours du temps Les premières machines contenaient de simples mono-processeurs. Les processeurs vectoriel ont fait leur apparition ensuite et sont capables d effectuer le décodage d une instruction et de l appliquer à toute une série d opérandes. Fin des années 1980, développement des architectures parallèles par Intel, AMD, PowerPC, RISC. Le Calcul Haute Performance Évolution des super-calculateurs 12 / 63

13 Distribution des processeurs De nos jours, voici la distribution des processeurs par marques dans les super-calculateurs. Le Calcul Haute Performance Évolution des super-calculateurs 13 / 63

14 1 Le Calcul Haute Performance Naissance des super-calculateurs Évolution des super-calculateurs Puissance de calcul et loi de Moore Utilisation et conception des super-calculateurs 2 Le Parallélisme Les différents types de parallélismes Les lois du parallélismes 3 La Programmation L optimisation du code source La programmation sous CPU La programmation sous GPU Le Calcul Haute Performance Puissance de calcul et loi de Moore 14 / 63

15 Loi de Moore Énoncé de Gordon Moore (1975) "The complexity for minimum component costs has increased at a rate of roughly a factor of two per year" Les modifications La période est passée de 2 ans à 18 mois On ne parle plus vraiment de complexité des composants mais du nombre de transistors Nombreuses variantes : doublement de la mémoire, doublement de la fréquence d horloge, doublement de la puissance de calcul... Le Calcul Haute Performance Puissance de calcul et loi de Moore 15 / 63

16 Puissance de calcul L unité de mesure La puissance de calcul est donnée en flops pour opérations à virgule flottante par seconde (Floating point Operations Per Second). Le Calcul Haute Performance Puissance de calcul et loi de Moore 16 / 63

17 1 Le Calcul Haute Performance Naissance des super-calculateurs Évolution des super-calculateurs Puissance de calcul et loi de Moore Utilisation et conception des super-calculateurs 2 Le Parallélisme Les différents types de parallélismes Les lois du parallélismes 3 La Programmation L optimisation du code source La programmation sous CPU La programmation sous GPU Le Calcul Haute Performance Utilisation et conception des super-calculateurs 17 / 63

18 Utilisation De nos jours, voici les domaines utilisant les super-calculateurs. Le Calcul Haute Performance Utilisation et conception des super-calculateurs 18 / 63

19 Conception Supériorité des super-calculateurs Une architecture particulière Conçu pour une tâche ou un but précis Utilisation du parallélisme pour contrer les limites physiques ou techniques Le Calcul Haute Performance Utilisation et conception des super-calculateurs 19 / 63

20 1 Le Calcul Haute Performance Naissance des super-calculateurs Évolution des super-calculateurs Puissance de calcul et loi de Moore Utilisation et conception des super-calculateurs 2 Le Parallélisme Les différents types de parallélismes Les lois du parallélismes 3 La Programmation L optimisation du code source La programmation sous CPU La programmation sous GPU Le Parallélisme 20 / 63

21 Définition Principe du parallélisme Le parallélisme consiste à utiliser des architectures parallèles permettant de traiter des informations de manière simultanée dans le but de réaliser le plus grand nombre d opérations par seconde. Le Parallélisme 21 / 63

22 Pour ou contre Avantages Limites Paradigme dominant depuis les années 2000 Contrer les contraintes physiques : dissipation thermique, consommation, miniaturisation... Contrer les contraintes techniques : fréquence, stabilité... Nouvelle approche et nouvelle vision Difficulté d implémentation et programmation Portabilité souvent limitée Le Parallélisme 22 / 63

23 1 Le Calcul Haute Performance Naissance des super-calculateurs Évolution des super-calculateurs Puissance de calcul et loi de Moore Utilisation et conception des super-calculateurs 2 Le Parallélisme Les différents types de parallélismes Les lois du parallélismes 3 La Programmation L optimisation du code source La programmation sous CPU La programmation sous GPU Le Parallélisme Les différents types de parallélismes 23 / 63

24 La taxonomie de Flynn Le classement de Michael J. Flynn Architecture SISD : systèmes séquentiels qui traitent une donnée à la fois (Single instruction Single Data) Architecture SIMD : systèmes parallèles traitant de grandes quantités de données d une manière uniforme (Single instruction Multiple Data) Architecture MIMD : systèmes parallèles traitant de grandes quantités de données d une manière hétérogène (Multiple instruction Multiple Data) Architecture MISD : systèmes parallèles traitant une seule donnée de manière hétérogène (Multiple instruction Single Data) Le Parallélisme Les différents types de parallélismes 24 / 63

25 La taxonomie de Flynn Le Parallélisme Les différents types de parallélismes 25 / 63

26 1 Le Calcul Haute Performance Naissance des super-calculateurs Évolution des super-calculateurs Puissance de calcul et loi de Moore Utilisation et conception des super-calculateurs 2 Le Parallélisme Les différents types de parallélismes Les lois du parallélismes 3 La Programmation L optimisation du code source La programmation sous CPU La programmation sous GPU Le Parallélisme Les lois du parallélismes 26 / 63

27 Les différentes lois Les lois du parallélisme La loi d Amdahl (1960) : la petite partie du programme qui ne peut être parallélisée limite la vitesse globale du programme La loi de Gustafson : analogue et prend en compte le cas où il est possible d augmenter la quantité de données sur lesquelles les calculs sont effectués en parallèle La métrique de Karp-Flatt (1990) : intègre le coût lié au temps d exécution des instructions qui mettent en œuvre le parallélisme Le Parallélisme Les lois du parallélismes 27 / 63

28 La loi d Amdahl Le Parallélisme Les lois du parallélismes 28 / 63

29 1 Le Calcul Haute Performance Naissance des super-calculateurs Évolution des super-calculateurs Puissance de calcul et loi de Moore Utilisation et conception des super-calculateurs 2 Le Parallélisme Les différents types de parallélismes Les lois du parallélismes 3 La Programmation L optimisation du code source La programmation sous CPU La programmation sous GPU La Programmation 29 / 63

30 Choisir sa solution Se poser les bonnes questions Utiliser le GPGPU Utiliser les processeurs multi-cœurs et multi-threads Utiliser les deux Vouloir une grande compatibilité Vouloir un plus grand contrôle Vouloir une plus grande accessibilité La Programmation 30 / 63

31 Les performances La Programmation 31 / 63

32 1 Le Calcul Haute Performance Naissance des super-calculateurs Évolution des super-calculateurs Puissance de calcul et loi de Moore Utilisation et conception des super-calculateurs 2 Le Parallélisme Les différents types de parallélismes Les lois du parallélismes 3 La Programmation L optimisation du code source La programmation sous CPU La programmation sous GPU La Programmation L optimisation du code source 32 / 63

33 Attention Premature optimization is the root of all evil Donald Knuth La Programmation L optimisation du code source 33 / 63

34 L optimisation Définition Optimisation : technique qui permet une exécution plus rapide du code source tout en gardant des résultats corrects et un niveau d erreur ou d approximation très faible. Règle de conduite 1. Utiliser un code fonctionnel 2. Identifier les parties "lourdes" du code (le profiling) 3. Optimiser seulement les parties identifiées Il existe des compilateurs et des outils permettant de réaliser un profiling du code automatiquement ou d identifier les zones "lourdes". La Programmation L optimisation du code source 34 / 63

35 Techniques Quelques exemples Utiliser le compilateur pour optimiser le code (Attention aux approximations et erreurs) Bien choisir ces types de variables Bien définir ces données selon le langage choisi Bien choisir les opérations et calculs effectués Favoriser les variables et calculs locales Faire attention aux boucles et conditions Faire attention aux fonctions créées et utilisées La Programmation L optimisation du code source 35 / 63

36 1 Le Calcul Haute Performance Naissance des super-calculateurs Évolution des super-calculateurs Puissance de calcul et loi de Moore Utilisation et conception des super-calculateurs 2 Le Parallélisme Les différents types de parallélismes Les lois du parallélismes 3 La Programmation L optimisation du code source La programmation sous CPU La programmation sous GPU La Programmation La programmation sous CPU 36 / 63

37 Présentation Les techniques de programmation MPI Message Passing Interface : environnement le plus connu pour les architectures à mémoires distribuées. Il offre aussi les meilleurs performances comparé à OpenMP OpenMP Multithreading : outil de programmation à base de directives pour l implémentation des programmes sur des systèmes à mémoire partagée. La Programmation La programmation sous CPU 37 / 63

38 MPI Parallélisation Le modèle de programmation MPI se place dans un contexte de parallélisation MIMD (Multiple Instruction Multiple Data) avec une mémoire distribuée. Quelques mots clefs MPI_Init : initialisation de MPI MPI_Comm_size : initialisation du nombre de processus MPI_Comm_rank : identification du processus MPI_Send : envoi d une valeur d une variable MPI_Recv : réception d une valeur d une variable MPI_Finalize : finalisation de MPI La Programmation La programmation sous CPU 38 / 63

39 Principe L exécution En MPI, le programme est dupliqué sur plusieurs processus. Chaque processus exécute un exemplaire du programme et a accès à sa mémoire propre. La Programmation La programmation sous CPU 39 / 63

40 Avantages et inconvénients Avantages Aucun langage à apprendre Une très grande portabilité Une très grande accessibilité Inconvénients Un gain de performance faible Une philosophie qui peut déranger un peu Doit être lancé avec mpirun La Programmation La programmation sous CPU 40 / 63

41 Démonstration Démonstration La Programmation La programmation sous CPU 41 / 63

42 Exemple 1 / Exemple 1 : H e l l o World / i n t main ( i n t argc, c h a r a r g v [ ] ) { i n t rank, s i z e ; MPI_Init (& argc, &a r g v ) ; MPI_Comm_rank (MPI_COMM_WORLD, &rank ) ; MPI_Comm_size (MPI_COMM_WORLD, & s i z e ) ; p r i n t f ( " P r o c e s s u s %d o f %d\n", rank, s i z e ) ; p r i n t f ( " H e l l o w o r l d " ) ; } MPI_Finalize ( ) ; r e t u r n 0 ; La Programmation La programmation sous CPU 42 / 63

43 Exemple 2 / Exemple 2 : Envoyer R e c e v o i r des v a l e u r s / i n t main ( i n t argc, c h a r a r g v [ ] ) { i n t rank, s i z e, a, t [ 4 ] = { 2, 3, 4, 5 } ; MPI_Init(& argc, &a r g v ) ; MPI_Comm_rank(MPI_COMM_WORLD,& rank ) ; MPI_Comm_size (MPI_COMM_WORLD,& s i z e ) ; MPI_Status s t a t ; i f ( rank == 0){ MPI_Send(&t, 4, MPI_INT, 1, 2,MPI_COMM_WORLD) ; } e l s e i f ( rank == 1){ MPI_Recv(&t, 4, MPI_INT, 0, 2,MPI_COMM_WORLD,& s t a t ) ; f o r ( a =0; a <4; a++){ p r i n t f ( " v a l e u r s t a b l e a u %i \n", t [ a ] ) ; } } [... ] MPI_Finalize ( ) ; r e t u r n 0 ; } La Programmation La programmation sous CPU 43 / 63

44 Exemple 3 / Exemple 3 : C a l c u l e r avec MPI / MPI_Init(& argc, &a r g v ) ; MPI_Comm_rank(MPI_COMM_WORLD,& rank ) ; MPI_Comm_size (MPI_COMM_WORLD,& s i z e ) ; MPI_Status s t a t u s ; [... ] i f ( rank==0) s t a r t t i m e = MPI_Wtime ( ) ; [... ] t c a r r e = ( bsup b i n f ) / s i z e ; b i n f p r o c = t c a r r e rank ; f o r ( i =0; i <p r e c ; i ++){ x = b i n f p r o c + ( i t c a r r e / p r e c ) ; tmp = tmp + ( ( t c a r r e / p r e c ) 1/(1+( x x ) ) ) ; } MPI_Reduce(&tmp,& pi, 1, MPI_DOUBLE, MPI_SUM, 0,MPI_COMM_WORLD) ; i f ( rank==0) [... ] endtime = MPI_Wtime ( ) ; } [... ] MPI_Finalize ( ) ; r e t u r n 0 ; La Programmation La programmation sous CPU 44 / 63

45 Exemple 4 / Exemple 4 : B r o a d c a s t des v a l e u r s / #i n c l u d e "mpi. h" #i n c l u d e <s t d i o. h> i n t main ( i n t argc, c h a r a r g v [ ] ) { i n t rank, s i z e, a =1; MPI_Init(& argc, &a r g v ) ; MPI_Comm_rank(MPI_COMM_WORLD,& rank ) ; MPI_Comm_size (MPI_COMM_WORLD,& s i z e ) ; MPI_Status s t a t u s ; MPI_Bcast (&a, 1, MPI_INT, 0, MPI_COMM_WORLD) ; p r i n t f ( " P r o c e s s u s %i : \ n V a l e u r s de a = %i \n", rank, s i z e, a ) ; } MPI_Finalize ( ) ; r e t u r n 0 ; La Programmation La programmation sous CPU 45 / 63

46 1 Le Calcul Haute Performance Naissance des super-calculateurs Évolution des super-calculateurs Puissance de calcul et loi de Moore Utilisation et conception des super-calculateurs 2 Le Parallélisme Les différents types de parallélismes Les lois du parallélismes 3 La Programmation L optimisation du code source La programmation sous CPU La programmation sous GPU La Programmation La programmation sous GPU 46 / 63

47 Le GPGPU À l origine À l origine : les puces graphiques servent uniquement à l affichage d images sur l écran. Une nouvelle fonction Au fil des années : la programmation et les capacités de ces puces graphiques ont évolué pour donner naissance au tout premier processeur graphique GPU. GPGPU Entre 1999 et 2000 : utilisation des GPUs pour exécuter des opérations de calculs scientifiques. C est l avènement du mouvement appelé GPGPU. La Programmation La programmation sous GPU 47 / 63

48 Présentation de CUDA CUDA Environnement logiciel permettant d utiliser le GPU au travers de langage de programmation : C, C++, Java,...). Il comporte les outils nécessaires à la création de fichier CUDA, il est une véritable extension au langage utilisé, permettant une exécution parallèle sur le GPU. La Programmation La programmation sous GPU 48 / 63

49 Fonctionnement de CUDA Les trois parties Runtime : c est l interface entre le GPU et l application Driver : son rôle est de transmettre les calculs de l application au GPU Librairies : CUDA est livré avec avec des implémentations d algorithmes optimisées pour cette architecture La Programmation La programmation sous GPU 49 / 63

50 Les éléments de CUDA Les différents éléments Threads : groupés en blocs qui coopèrent et traitent le même code sur des données différentes Blocs : groupés en grilles et s exécutent dans n importe quel ordre Kernels : fonctions appelées depuis l host et exécutées sur le device La Programmation La programmation sous GPU 50 / 63

51 La mémoire Les différentes mémoires La mémoire globale La mémoire constante La mémoire texture La mémoire partagée Les registres La Programmation La programmation sous GPU 51 / 63

52 Principe et philosophie Répartition des rôles Chaque kernel est associé avec une grille sur le device. Le choix du nombre de threads et de blocs est conditionné par la nature de l application et la nature des données à traiter. Chaque thread dispose d un ID appelé threadidx. Les variables blockdim et threadidx sont définies automatiquement et sont de type dim3. Les threads et les blocs peuvent être organisés suivant une, deux ou trois dimensions. Chaque dimension est accédée par la notation threadidx.x, threadidx.y et threadidx.z. La Programmation La programmation sous GPU 52 / 63

53 Exécution La Programmation La programmation sous GPU 53 / 63

54 Un mot sur OpenCL Présentation OpenCL est un environnement de programmation sous GPU ressemblant beaucoup à CUDA avec une philosophie similaire. Les différences Utilisable avec tout les GPUs Création de systèmes hybrides Gestion de la mémoire différente Un langage plus haut niveau Une communauté un peu moins grande La Programmation La programmation sous GPU 54 / 63

55 Avantages et inconvénients Avantages Des performances impressionnantes Un centre de calcul à un prix ridicule Une communauté très importante Un environnement complet de programmation Inconvénients Une vision très différente de la programmation Portabilité sur les GPUs de la marque Accessibilité faible Une optimisation difficile La Programmation La programmation sous GPU 55 / 63

56 Démonstration Démonstration La Programmation La programmation sous GPU 56 / 63

57 Exemple 1 / Exemple 1 : H e l l o World / #i n c l u d e " main. h" i n t h e l l o W o r l d ( v o i d ) { p r i n t f ( " H e l l o W o r l d! \ n" ) ; } system ( " pause " ) ; r e t u r n 0 ; La Programmation La programmation sous GPU 57 / 63

58 Exemple 2 / Exemple 2 CUDA / #i n c l u d e " main. h" #d e f i n e N 10 global v o i d add ( i n t a, i n t b, i n t c ) { i n t t i d = b l o c k I d x. x ; i f ( t i d < N) c [ t i d ] = a [ t i d ] + b [ t i d ] ; } i n t a d d i t i o n V e c t e u r ( v o i d ) { i n t a [N], b [N], c [N ] ; i n t dev_a, dev_b, dev_c ; // a l l o c a t e t h e memory on t h e GPU cudamalloc ( ( v o i d )&dev_a, N s i z e o f ( i n t ) ) ; cudamalloc ( ( v o i d )&dev_b, N s i z e o f ( i n t ) ) ; cudamalloc ( ( v o i d )&dev_c, N s i z e o f ( i n t ) ) ; f o r ( i n t i =0; i <N; i ++) { a [ i ] = i ; b [ i ] = i i ; } [... ] La Programmation La programmation sous GPU 58 / 63

59 Exemple 2 suite [... ] // copy t h e a r r a y s a and b to t h e GPU cudamemcpy ( dev_a, a,n s i z e o f ( i n t ), cudamemcpyhosttodevice ) ; cudamemcpy ( dev_b, b,n s i z e o f ( i n t ), cudamemcpyhosttodevice ) ; add<<<n,1>>>( dev_a, dev_b, dev_c ) ; // copy t h e a r r a y c back from t h e GPU to t h e CPU cudamemcpy ( c, dev_c,n s i z e o f ( i n t ), cudamemcpydevicetohost ) ; } f o r ( i n t i =0; i <N; i ++) { p r i n t f ( "%d + %d = %d\n", a [ i ], b [ i ], c [ i ] ) ; // f r e e t h e memory a l l o c a t e d on t h e GPU cudafree ( dev_a ) ; cudafree ( dev_b ) ; cudafree ( dev_c ) ; } system ( " pause " ) ; r e t u r n 0 ; La Programmation La programmation sous GPU 59 / 63

60 Exemple 3 / Exemple 3 : C a l c u l de p i / #i n c l u d e " main. h" #d e f i n e P r e c i s i o n global v o i d c a l c ( f l o a t i n t e r v, f l o a t r e s u l t ){ i n t t i d = b l o c k I d x. x ; i f ( t i d < P r e c i s i o n ) r e s u l t [ t i d ] = ( ( 1. 0 / P r e c i s i o n ) 1 / (1 + ( i n t e r v [ t i d ] i n t e r v [ t i d ] ) ) ) ; } i n t calculpigpu ( v o i d ) { f l o a t p i = 0. 0 ; f l o a t i n t e r v a l l e [ P r e c i s i o n ], r e s u l t a t [ P r e c i s i o n ] ; f l o a t d e v _ i n t e r v, d e v _ r e s u l t ; // a l l o c a t e t h e memory on t h e GPU cudamalloc ( ( v o i d )& d e v _ i n t e r v, P r e c i s i o n s i z e o f ( f l o a t ) ) ; cudamalloc ( ( v o i d )& d e v _ r e s u l t, P r e c i s i o n s i z e o f ( f l o a t ) ) ; // f i l l t h e a r r a y s i n t e r v and r e s u l t on t h e CPU [... ] La Programmation La programmation sous GPU 60 / 63

61 Exemple 3 suite [... ] // copy t h e a r r a y s a and b to t h e GPU cudamemcpy ( d e v _ i n t e r v, i n t e r v a l l e, P r e c i s i o n s i z e o f ( i n t ), cudamemcpyhosttodevice ) ; c a l c <<<P r e c i s i o n,1>>>( d e v _ i n t e r v, d e v _ r e s u l t ) ; // copy t h e a r r a y c back from t h e GPU to t h e CPU cudamemcpy ( r e s u l t a t, d e v _ r e s u l t, P r e c i s i o n s i z e o f ( f l o a t ), cudamemcpydevicetohost ) ; // r e s u l t s f o r ( i n t i =0; i <P r e c i s i o n ; i ++) { p i = p i + r e s u l t a t [ i ] ; } p i = p i 4 ; p r i n t f ( " p i = %f \n", p i ) ; // f r e e t h e memory a l l o c a t e d on t h e GPU cudafree ( d e v _ i n t e r v ) ; cudafree ( d e v _ r e s u l t ) ; } r e t u r n 0 ; La Programmation La programmation sous GPU 61 / 63

62 Exemple 3 amélioration / Exemple 3 : O p t i m i s a t i o n / device f l o a t c a l c u l I n t e r v a l l e ( i n t t i d ){ r e t u r n t i d ( 1. 0 / P r e c i s i o n ) ; } global v o i d c a l c ( f l o a t r e s u l t ) { i n t t i d = b l o c k I d x. x ; f l o a t x = c a l c u l I n t e r v a l l e ( t i d ) ; i f ( t i d < P r e c i s i o n ) r e s u l t [ t i d ] = ( ( 1. 0 / P r e c i s i o n ) 1 / (1 + ( x x ) ) ) ; } i n t calculpigpu2 ( v o i d ) { f l o a t p i = 0. 0 ; f l o a t r e s u l t a t [ P r e c i s i o n ] ; f l o a t d e v _ r e s u l t ; cudamalloc ( ( v o i d )& d e v _ r e s u l t, P r e c i s i o n s i z e o f ( f l o a t ) ) ; c a l c <<<P r e c i s i o n,1>>>( d e v _ r e s u l t ) ; [... ] La Programmation La programmation sous GPU 62 / 63

63 Exemple 4 / Exemple 4 : C a l c u l avec des B l o c s e t des Threads / c o n s t i n t N = ; c o n s t i n t t h r e a d s P e r B l o c k = ; c o n s t i n t b l o c k s P e r G r i d = 3 2 ; global v o i d dot ( f l o a t a, f l o a t b, f l o a t c ) { shared f l o a t cache [ t h r e a d s P e r B l o c k ] ; i n t t i d = t h r e a d I d x. x + b l o c k I d x. x blockdim. x ; i n t c a c h e I n d e x = t h r e a d I d x. x ; f l o a t temp = 0 ; w h i l e ( t i d < N) { temp += a [ t i d ] b [ t i d ] ; t i d += blockdim. x griddim. x ; } cache [ c a c h e I n d e x ] = temp ; syncthreads ( ) ; i n t i = blockdim. x / 2 ; w h i l e ( i!= 0) { i f ( c a c h e I n d e x <i ) cache [ c a c h e I n d e x ]+=cache [ c a c h e I n d e x+i ] ; syncthreads ( ) ; i /= 2 ; } i f ( c a c h e I n d e x == 0) c [ b l o c k I d x. x ] = cache [ 0 ] ; } La Programmation La programmation sous GPU 63 / 63