Introduction à la programmation massivement parallèle

Transcription

1 Introduction à la programmation massivement parallèle L exemple d opencl F. Sailhan CNAM, département informatique November 21, 2014

2 Plan 1 Introduction 2 Notions de base sur le parallélisme Architecture 3 OpenCL Modèles Modèle d éxécution Mon premier Programme Premier bilan Deuxième Programme 4 Conclusion F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

3 Pourquoi étudier la programmation parallèle? Les contres 1 Les performances d un même logiciel s améliorent à chaque nouvelle génération de processeur, 2 Nous sommes habitués à la programmation séquentielle, 3 La programmation parallèle, ce n est pas nouveaux et pourtant, peu d applications l utilisent... 4 Depuis 2003, le multi coeur... 5 Les data centers, le Facebook Data Center on April 19, 2012 in Forest City, North Carolina. F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

4 Pourquoi étudier la programmation parallèle? Oui mais... 1 Cette cadence se ralentit en 2003 : la consommation d énergie et la dissipation de chaleur limitent la fréquence des horloges, 2 Plus besoin d ordinateurs coûteux... : la programmation devient parallèle avec le multi-coeur, massivement parallèle avec les GPU (Graphic Processing Units) Exigence temps réelles (toucher l écran d un smartphone) 20 capteurs par smartphone (caméras, microphones), systèmes embarqués (voitures) Résolution plus poussée (20 fois plus de pixels) accélération CPU impossible à moins de vider la batterie F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

5 Pourquoi étudier la programmation parallèle? F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

6 To be or not to be? CPU or GPU? la fausse question 4 multi-coeurs optimisés pour une exécution séquentielle 1 Une logique de contrôle sophistiquée au service de l éxecution parrallèle d un seul thread 2 Large mémoire cache avec accès réduit aux intructions + données GPU = pleins de multi-processeurs = parallélisation massive 1 Mémoire globable: DRAM DRAM de carte mère bande passante GPU et mémoire globale = 20 fois plus rapide qu avec la DRAM de la carte mère. Chip G80: 8GB/s DRAM-CPU et 86,4GB DRAM-GPU. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

7 L histoire des GPUs En 3 mots Années : les fonctionalités graphiques sont pipelinées au niveau hardware. Elles sont configurables mais pas programmables Années 2000: Nvidia développe le compilateur CUDA C, C++, les librairies à destination des programmeurs, Consortium Kronos crée pour développer d un standard ouvert (middleware + langage), cross-plateforme F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

8 Standards ouverts spécifiés par le groupe Khronos Khronos connecting software to silicon, OpenCL = API de calcul que nous verrons OpenGL = API graphique WebGL et WebCL = API pour l accélération graphique et accélération des calculs pour le Web (dans les navigateurs) Collada: exchange d information 3D entre applications OpenGL ES : API graphique pour les systèmes embarqués (smartphones, display, automobile) Stream input = API pour l interaction avec les capteurs générant des flux, combiner les flus OpenKcam : fusion (caméra) et contrôle (actuator) F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

9 Parallélisme : taxonomie de Michael J. Flynn Classification basée sur la concurrence des flux d instructions & données Flux d instructions = ensemble d instructions formant un processus Flux de données = données sur lesquelles le processus opère Single Instruction, Single Data stream (SISD): système séquentiel : 1 flux d instructions opère sur 1 donnée Single Instruction, Multiple Data streams (SIMD): 1 instruction diffusée à plusieurs unités de calcul ;chacune opère la même instruction sur différentes données Multiple Instruction, Single Data stream (MISD): plusieurs flux d instructions opèrent sur le même flux de données Multiple Instruction, Multiple Data streams (MIMD): plusieurs unités de calculs opèrent sur plusieurs flux de données au moyen de plusieurs flux d instructions F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

10 Parallélisme MISD, MIMD : 2 modèles mémoire Par mémoire distribuées # processeurs (spécialisés ou non) sont connectés à la mémoire via un réseau haut débit (Myrinet, Infiniband, 10Gbit Ethernet), mémoire Exemple : cluster de serveurs, MPP (Massively Parallel Processor) cf la liste des plus puissants : Chaque processeur dispose de son propre espace d adressage Inconvénient : transfert lent comparé à un accès locale en mémoire adapté aux applications peu communicantes Par mémoire partagée 1 tous les processeurs partagent le même espace d adressage et communiquent entre eux par lecture/écriture dans la mémoire partagée F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

11 Parallélisme MIMD : 2 modèles mémoire Par mémoire distribuées Les interactions se font par passage de message entre les processeurs Inconvénient : portage difficile d un programme séquentiel Exemple: langage MPI (Message Passing Interface) utilisé pour des clusters distribués (jusqu à noeuds) Par mémoire partagée 1 Cohérence forte quelques centaines de noeuds Exemple : Open MP (Open Multi-processing) 2 Cohérence relaxée : une mémoire partagée de petite taille Exemple : Cuda, Opencl F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

12 Parallélisme logiciel La parallélisation consiste à: 1 Analyser des dépendances au niveau des structures de données et des processus 2 Déterminer le meilleure algorithme/framework pour exécuter le code 3 Réecrire du code avec un framework tel que Message Passing Interface (MPI) ou OpenCL Parrallélisme des données Les sections de programme sont caractérisées par un parallélisme important des données ce qui permet d effectuer des opérations arithmétiques en parallèle sans danger F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

13 Parallélisme logiciel - Performances Lois des % du code est parallélisable,90 % du code est séquentiel, Idée : en terme de temps d éxécution, nous passons la plupart du temps dans les 10% du code Evaluation du bénéfice : loi d Amdahl S = 1 (1 P)+ P N N : nombre de processeurs, P : fraction du temps pris par la portion de code parallélisable S : rapidité F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

14 Parallélisme de contrôle - Parallélisme de données for(i=0;i<n;i++) { resulta = taska(i); resultb = taskb(i); resultc = taskc(i); } Parallélisme de données Les données sont partionnées Exemple: chaque processeur gère N/3 itérations de la boucle Avantage : plusieurs processeurs exécutent le même programme et finissent en même temps Parallélisme de contrôle Chaque processeur exécute une tâche de la boucle Inconvénient: désynchronisation Solution: partage équitable de la charge (gestion d une queue des F. Sailhan (CNAM, tâches département à assigner informatique) sur Introduction les processeur) à la programmation massivement parallèle November 21, / 54

15 1 Introduction 2 Notions de base sur le parallélisme Architecture 3 OpenCL Modèles Modèle d éxécution Mon premier Programme Premier bilan Deuxième Programme 4 Conclusion F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

16 Architecture GPU Grappes de multi-processeurs partageant un cache d instructions et la même logique de contrôle Chaque multi-processeur dispose d une unité MAD (Multiply-Add) et (Add-Multiply) et de fonctions particulières (exemple la racine carrée) Chaque multi-processeur exécute un parallélisme massif (plusieurs milliers de threads). Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

17 Exemple d architecture: Kepler GK100 de NVIDIA Dernière génération (2014) : Kepler = Fermi * 2 = 1536KB de cache L2 partagé par 15 SMX = 15 clusters contenant chacun 4 schedulers de 32 threads Chaque SMX dispose de 64KB (mémoire partagée + cache L1) + cache (read only) de F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

18 Exemple d architecture: Kepler GK100 Chaque thread a accès à 255 registres + les mémoires hierarchisées Opération atomiques (add, min, mac, compare and swap) Nouveauté : parallélisme dynamique = récursivité permise = planification à la F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

19 OpenCL (Open Computing Language) Definition a framework suited for parallel programming of heterogeneous systems Objectifs Utiliser toutes les ressources : à la fois CPU multi-coeurs et GPU : même code exécutable sur CPU/GPU (minus quelques optimisations) la parallélisation des tâches et des données Un modèle de programmation haut niveau basé sur le C Cross-platform, cross-vendeur, cross-os (android,...) API pour accéder à la plateforme : abstraction du matériel (mémoire, GPU ect...) API pour l exécution : exécution transparente des threads, gestion transparente des queues, des ressources mémoires F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

20 Modélisation de la mémoire Un modèle facilement retransposable sur les architectures matérielles. Celui de Cuda est casiment similaire. F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

21 Modélisation de la mémoire Mémoire privée : chaque work-item dispose d une mémoire privée qui est la plus rapide d accès, sans primitive de synchronisation, et est allouée/partitionnée à la compilation pour ledit kernel et ladite carte : sa taille est inconnue Mémoire locale : Mémoire partagée par tout un work group : chaque workitem du même work group peut y accéder. Générallement sur ship Mémoire globale accessible par tous les workgroup, est non synchronisée, possiblement constant (c-a-d en lecture seule) : mémoire la plus large (GB), Mémoire globale de l hôte la plus lente d accès mais la plus conséquente. Mémoire à éviter (temps de chargement important : mieux vaut garder le maximum possible, le plus longtemps possible sur le GPU) F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

22 Accès à la mémoire Espace d adressage: private (au work-item), local (workitems d un même workgoup), global (accessible par tous les workitems de tous les work groups), constante (read only pour la mémoire globale) Gestion explicite de la mémoire: les types de mémoire doivent être explicitement définis au niveau du code en raison du manque de mémoire des transbordements dont le coût diffère suivant le type de mémoire Modèle relaxé d accès à une mémoire partagée La vision d un work-item n est pas toujours celle des autres Nécessité de ce synchroniser avec des barrières. Exemple: attendre que tous les work-items aient écris avant de lire. Cette synchronisation est très coûteuse. F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

23 Vocabulaire Definition host = le système de calcul = CPU (Central Processing Unit) traditionnel équipé de nombreux arithmetic execution units. device = GPU Un programmeur définie des fonctions devant s éxécuter sur le device. Chaque fonction est appelée un kernel Organisation du programme Un programme OpenCL est divisé en deux parties : une partie s exécute sur l hôte (partie non parrallélisée) Une partie s éxécutant sur le GPU (partie parallélisée) F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

24 Modèle d exécution F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

25 Modèle d exécution Work-item: équivalent d un thread (= plus petite entité d exécution). L exécution d un kernel se fait sur un ensemble de work-items dont le nombre est paramétré par le développeur. Chaque work-item exécute le même code. Chaque work item est identifié (ID), Work-group: ensemble de work-items coopérant ensemble au sein d un work-groups. Reflète l organisation des work-items en grille de 1, 2, 3 dimensions. Est identifié par un ID ND-Range : niveau d organisation des work-groups = 1, 2 ou 3 dimensions F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

26 Premier programme Objectif : ajouter deux vecteurs 1 Développer une fonction=kernel appelée vector add qui ajoute deux vecteurs. Cette fonction est placée un fichier appelé vecteur.cl. 2 Développer toute le code permettant de lancer en parallèle les threads permettant d ajouter les deux vecteurs. Placer ce code dans un fichier vecteur.c. 3 Compiler + exécuter Consulter : F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

27 Kernel ajoutant deux vecteurs kernel void vector_add( global const float* src_a, global const float* src_b, global float* res, const int num) { } 2 vecteurs en entrées src a src b, un résultat res, #threads s exécutent. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

28 Kernel ajoutant deux vecteurs kernel void vector_add( global const float* src_a, global const float* src_b, global float* res, const int num) { const int idx = get_global_id(0); if (idx < num) { res[idx] = src_a[idx] + src_b[idx]; } } 2 vecteurs en entrées src a src b, un résultat res, #threads s exécutent get local id renvoie l identifiant du workitem s exécutant F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

29 Kernel - Développement Le language utilisé est basé sur l ANSI C99. Lors du développement d un kernel 3 aspects sont à considérer : 1 Il faut déterminer lors du passage des arguments le type de mémoire utilisé, c est à dire de l espace d adressage qui est soit : global : espace d adressage global constant : région de la mémoire en lecture seulement local : mémoire partagée par le work-group. private: mémoire du work-item. 2 Attention: chaque type d adressage est distinct, ce qui signifie que tous les mouvements de données doivent être explicites. 3 Les méthodes fournissant un accès au domaine de calcul F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

30 Premier programme : programmation de l hôte (host) Vous devez impérativement consulter la spécification du language très bien résumée par l OpenCL Quick Reference Card disponible à l url : Ce guide contient les types de base, les fonctions mathématiques, géométriques... dont il faut privilégier l utilisation F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

31 Premier programme : programmation de l hôte (host) Etape suivante déveloper l environnement autours permettant d exécuter le kernel : fichier séparé : vecteur.c Pour compiler et exécuter, taper en ligne de commande : $ gcc -o vect vecteur.c -lopencl $./vect #include <stdio.h> #include <stdlib.h> #ifdef APPLE #include <OpenCL/opencl.h> #else #include <CL/cl.h> #endif int main(void) {...} F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

32 Premier programme : programmation de la plateforme Platform hôte + ensemble de devices gérés par OpenCL. Permet à une application de partager les ressources et d exécuter les kernels sur les devices au sein de la plateforme Est représenté par l objet a cl latform object initialisé par la fonction suivante : cl_int oclgetplatformid (cl_platform_id *platforms) F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

33 Premier programme : initialisation du device Device Deux types de devices sont gérés par OpenCl: device type =CL DEVICE TYPE GPU pour GPU, CL DEVICE TYPE CPU pour CPU Le nombre de devices (typiquement 1) est défini num entries Le(s) device(s) sont initialisés par la fonction ci-dessous : cl_int clgetdeviceids (cl_platform_id platform, cl_device_type device_type, cl_uint num_entries, cl_device_id *devices, //pointeur : liste des devices cl_uint *num_devices) //#devices dont le type a été défini F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

34 Premier programme : initialisation du context Context est utilisé par l environnement d exécution d OpenCL (ses kernels, devices, gestionnaire de mémoire, queue(s) de commandes) est référencé par l objet cl context object, initialisé par la fonction ci-dessous: cl_context clcreatecontext (const cl_context_properties *prope // Bitwise with the properties CL_CONTEXT_PLATFORM cl_uint num_devices, //#devices const cl_device_id *devices, // Pointeur sur les devices void *pfn_notify(const char *errinfo, const void *private_info, size_t cb, void *user_data), //fonction de call utilisée pour les notifications void *user_data, // paramètres de la fonction ci-dessus cl_int *errcode_ret) // erreur renvoyée (aucune si = NULL) F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

35 Premier programme : queue de commande CommandQueue est utilisé pour empiler les commandes à exécuter. Plusieurs queues peuvent être crées (les commandes sont alors indépendantes et non synchronisées) est référencé par l objet cl command queue, initialisé par la fonction ci-dessous: cl_command_queue clcreatecommandqueue (cl_context context, cl_device_id device, cl_command_queue_properties properties, //bitwise cl_int *errcode_ret) //erreur renvoyée (aucune si = NULL) Les éléments basiques de l hôte sont maintenant configurés F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

36 Premier programme : plateforme, contexte, queue cl_platform_id platform; cl_context context; cl_command_queue queue; cl_device_id device; //cl_int error = 0; // Platform error = oclgetplatformid(&platform); //if (error!= CL_SUCCESS) exit(error); // Device clgetdeviceids(platform,cl_device_type_gpu,1,&device,null); // Context context = clcreatecontext(0, 1, &device, NULL, NULL, &error); // Command-queue queue = clcreatecommandqueue(context, device, 0, &error); F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

37 Premier programme : allocation de la mémoire Mémoire les variables à passer au kernel (entrées et sorties) doivent être définies La mémoire allouée sur le device est de type: CL MEM READ WRITE CL MEM WRITE ONLY CL MEM READ ONLY CL MEM USE HOST PTR : utilisation de la mémoire de l hôte CL MEM ALLOC HOST PTR : mémoire de l hôte allouée et rendue accessible CL MEM COPY HOST PTR :copie la mémoire pointée par host ptr cl_mem clcreatebuffer (cl_context context, cl_mem_flags flags, //type de mémoire size_t size, // taille exprimée en octets void *host_ptr, cl_int *errcode_ret) F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

38 Premier programme : allocation de la mémoire Mémoire Allocation de 3 vecteurs src a d, src b d, res d, initialisation de src a d, src b d Allocation des buffers: 2 en lecture et 1 en écriture (résultat) const int size = ; float* src_a_h = new float[size]; float* src_b_h = new float[size]; float* res_h = new float[size]; for(int i=0; i<size; i++) {src_a_h = src_b_h = (float) i;} const int mem_size = sizeof(float)*size; cl_mem src_a_d = clcreatebuffer(context, CL_MEM_READ_ONLY CL_MEM_COPY_HOST_PTR, mem_size, src_a_h, &error); cl_mem src_b_d = clcreatebuffer(context, CL_MEM_READ_ONLY CL_MEM_COPY_HOST_PTR, mem_size, src_b_h, &error); cl_mem res_d = clcreatebuffer(context, CL_MEM_WRITE_ONLY, mem_size, NULL, &error); F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

39 Premier programme: remarques Il existe deux façons de compiler : Compilation en ligne : le fichier source contenant le kernel est lu dans le code de l hôte (solution que nous adoptons par la suite) Built du kernel lors de l éxécution (OpenCL runtime library) Avantage : portabilité, facilite les tests du kernel Inconvénient : la compilation du kernel doit être effectué par le terminal où il est déployé (solution inadaptée aux systèmes embarqués) Compilation hors ligne : le fichier binaire du kernel est lu par le code de l hôte Pre-built du kernel par le compilateur OpenCL. Le binaire généré est chargé (OpenCL API). Avantage : rapidité Inconvénient : portabilité F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

40 Premier programme : lancement du programme Programme Un programme (= ensemble de kernels) est crée puis compilé // Création du programme cl_program clcreateprogramwithsource (cl_context context, cl_uint count/*#fichiers*/, const char **strings /*noms fichiers*/, const size_t *lengths/*longueurs des fichiers*/, cl_int *errcode_ret) //Compilation du programme cl_int clbuildprogram(cl_program program, cl_uint num_devices, const cl_device_id *device_list, const char *options, // options compilation void (*pfn_notify)(cl_program, void *user_data), void *user_data) F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

41 Premier programme : lancer le kernel Une fois crée, le kernel est lancé après définission des arguments. Sa compilation a lieu lors de l exécution // 1. Création de kernel : cl_kernel clcreatekernel (cl_program program, const char *kernel_name, cl_int *errcode_ret) //2. Définition de chaque argument cl_int clsetkernelarg(cl_kernel kernel, cl_uint arg_index,//qu argument size_t arg_size,//taille PROCHAIN argument const void *arg_value) // Valeur // 3. Appel du kernel cl_int clenqueuendrangekernel(cl_command_queue command_queue, cl_kernel kernel, cl_uint work_dim /*1D,2D,3D*/, const size_t *global_work_offset, const size_t *global_work_size//#work-ite, const size_t *local_work_size, //#work-items par work-group cl_uint num_events_in_wait_list, const cl_event *event_wait_list, cl_event *event) F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

42 Premier programme : lancer le kernel // 1. Création du programme size_t src_size = 124; const char* path = shrfindfilepath("vecteur.cl", NULL); const char* source = oclloadprogsource(path, "", &src_size); cl_program program = clcreateprogramwithsource(context, 1, &source, &src_size, &error); error = clbuildprogram(program, 1, &device,null,null,null); cl_kernel vector_add_kernel = clcreatekernel(program, "vector_add_gpu", &error); F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

43 Premier programme : lancer le kernel // Arguments placés dans la queue clsetkernelarg(vector_add_k, 0, sizeof(cl_mem), &src_a_d); clsetkernelarg(vector_add_k, 1, sizeof(cl_mem), &src_b_d); clsetkernelarg(vector_add_k, 2, sizeof(cl_mem), &res_d); clsetkernelarg(vector_add_k, 3, sizeof(size_t), &size); // Lancement du kernel const size_t local_ws = 512; // #work-items par work-group //shrroundup renvoie le + petit multiple de local_ws > size const size_t global_ws = shrroundup(local_ws, size); //#work-items total error = clenqueuendrangekernel(queue, vector_add_k, 1, NULL, &global_ws, &local_ws, 0, NULL, NULL); F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

44 Premier programme : lecture des résultats, libération cl_int clenqueuereadbuffer (cl_command_queue command_queue, cl_mem buffer, // à partir de quel buffer cl_bool blocking_read, // lecture bloquante ou non size_t offset, // offset depuis le début size_t cb, // combien d octets lire void *ptr, // pointer sur la mémoire de l hote cl_uint num_events_in_wait_list, const cl_event *event_wait_list, cl_event *event) lecture des résultats et libération des ressources allouées : float* check = new float[size]; clenqueuereadbuffer(queue, res_d, CL_TRUE, 0, mem_size, check, 0, NULL, NULL); clreleasekernel(vector_add_k); clreleasecommandqueue(queue); clreleasecontext(context); clreleasememobject(src_a_d); clreleasememobject(src_b_d); F. Sailhan clreleasememobject(res_d); (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

45 Premier bilan: restriction Le parallélisme des données : il existe une corrélation entre les identifiants et l organisation des work-items et les accès en mémoire. Contrôle de flôt: il est important que les même instructions soient exécutées. Si plusieurs chemins peuvent être empruntés, les différents chemins seront sérialisés Restrictions : pas de pointeur passé en argument au kernel, pas de tableau de taille variable, pas de récursion (pour les GPUs anciens) F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

46 Premier bilan: mise en garde Le GPU parallélise efficacement si : la même opération est effectuée sur un ensemble de données (de taille relativement modérée) Chaque work-item fait des accès cohérents en mémoire GLOBALE : accès regroupés et séquentiels La mémoire globale est une sucession de mots de 16 ou 32 bits. Ici, chaque thread accède à un float (= 32 bits) en mémoire Cas 1: accès séquentiel aligné : 1 transaction Cas 2: accès séquentiel non aligné = 2 transactions Cas 3: accès séquentiel espacé = 2 transactions F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

47 Premier bilan: calcul de la bande passante théorique Le GPU parallélise efficacement si : la même opération est effectuée sur un ensemble de données (de taille relativement modérée) Les échanges d informations entre l hôte et le device sont minimisés car le bus PCI manque de bande passante Le coût de chargement des données de l hôte vers le device (et vis versa) est justifié. Coût injustifiable pour l addition de 2 vecteurs. Pour l addition de 2 matrices? le carré d une matrice? Hypothèses : NVIDIA GeForce GTX 280 DDR (Double Data Rate) RAM avec une cadence d horloge (memory clock) de 1,107 MHz et une interface mémoire à 512-bits Question: Quelle est la bande passance théorique (max)? Réponse : (512/8).2)/10 9 = 141.6Gbytes/sec Bande passante effective = ((Br + Bw)/10 9 )/time Br : nb d octets lus par kernel, Bw : nb d octets écris par kernel i, time : exprimé en seconde. Exemple : pour la copie d une matrice 2048 x 2048, bande passante effective = /10 9 F. Sailhan (CNAM, département informatique) Introduction à la programmation /time massivement parallèle November 21, / 54

48 A vous de jouer Objectif: multiplier une matrice par un vecteur, voir deux matrices Rappel: multiplication matrice par vecteur a b c 1 a + 2.b + 3.c d e f 2 = d + 2.e + 3.f g h i 3 g + 2.h + 3.i Rappel: multiplication de 2 matrices a b c j k l d e f m n o = g h i p q r a.j + b.m + c.p a.k + b.n + c.q a.l + b.o + c.r d.j + e.m + f.p d.k + e.n + f.q d.l + e.o + f.r g.j + h.m + i.p g.k + h.n + i.q g.l + h.o + i.r Stratégie: sachant que l accès à la mémoire globale est très lent, maximisez le nombre d accès à la mémoire partagée (locale) F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

49 Rappel: fonction multipliant la matrice M par le vecteur V La fonction ci-dessous n est pas parallélisée matrix_vector_mul(const float* M, uint width, uint height, const float* V, float* W) { for (uint y = 0; y < height; ++y) { const float* row = M + y * width; } row pointe au début de chaque ligne identifiée par y F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

50 Rappel: fonction multipliant la matrice M par le vecteur V La fonction ci-dessous n est pas parallélisée matrix_vector_mul(const float* M, uint width, uint height, const float* V, float* W) { for (uint y = 0; y < height; ++y) { const float* row = M + y * width; float dotproduct = 0; for (uint x = 0; x < width; ++x) dotproduct += row[x] * V[x]; W[y] = dotproduct; } } row pointe au début de chaque ligne identifiée par y F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

51 Work-item multipliant une matrice par un vecteur kernel void MatrixVectorMul0(const global float* M, uint width, uint height, const global float* V, global float* W) { uint y = get_global_id(0); const float* row = M + y * width; float dotproduct = 0; for (uint x = 0; x < width; ++x) dotproduct += row[x] * V[x]; W[y] = dotproduct; } Invonvénient : un work-item calcul une ligne et risque d être inoccupé. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

52 Work-item multipliant une matrice par un vecteur kernel void MatrixVectorMul1(const global float* M, uint width, uint height, const global float* V, global float* W) { unint y; for (y=get_global_id(0); y<height; y+=get_global_size(0)) { const float* row = M + y * width; float dotproduct = 0; for (uint x = 0; x < width; ++x) dotproduct += row[x] * V[x]; W[y] = dotproduct; } } F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

53 Premier bilan Le nombre d éléments calculé par chaque work-item = height/ # work-items (+1 pour certains work-items si height n est pas un multiple du # work-items) Avantage : découplage entre la taille de la matrice et le nombre de work-item s exécutant Remarque: un kernel doit s exécuter sur un #work-items #multiprocesseurs. centaines de work-items par multiprocessor qui seraient un multiple de la taille de warp (= 32). Le meilleur NDRange dépend du kernel, du #registres et doit être fixé par des expérimentations Autres optimisations : l accès contigu à la mémoire permettant une seule transaction mémoire F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

54 Accès mémoire, multiplication matrice par un vecteur kernel void MatrixVectorMul1(...) { unint y; for(y=get_global_id(0);y<height;y+=get_global_ { const float* row = M + y * width; float dotproduct = 0; for (uint x = 0; x < width; ++x) dotproduct += row[x] * V[x]; W[y] = dotproduct; } }. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

55 Accès mémoire, multiplication matrice par un vecteur kernel void mul( global float*m, uint width,uint height, global float* V, global float* W, local float* partprod) for(y=get_group_id(0); y<height; y +=get_num_groups(0)){ float sum = 0; for(uint x=get_local_id(0);x<width;x+=get_local_size(0)) sum += row[x] * V[x]; partprod[get_local_id(0)]=sum; if (get_local_id(0) == 0) { float dotproduct = 0; for (uint t = 0; t < get_local_size(0); ++t) dotproduct += partprod[t]; W[y] = dotproduct; } barrier(clk_local_mem_fence);}} F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

56 Conclusion: GPU for ever? Nous assistons à une renaissance du calcul parallèle caractérisé par une utilisation efficace de toutes les ressources, une utilisation avisée de la concurrence. Critère primordiale : sélectionner le bon matériel en fonction de l algorithme GPU = processeur massivement multi-coeur caractérisé par une exécution SIMD GPU = special purpose hardware (parallélisme des données) Implication multiples: les algorithmes doivent être impérativement désignés pour éviter toute divergence au niveau des branchements. Leur massivité implique de les maintenir occupés Difficulté à debuger le code CPU = general purpose hardware parfait pour un code série ou un faible parallélisme avec de petites unités de travail dont les tâches à effectuer ne sont pas reliées, facile à débuger, outils mature F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54

57 David B. Kirk and Wen-mei W. Hwu Programming massively parallel processors A Hands-on approach laurel.datsi.fi.upm.es/ media/proyectos/gopac/programming massively parallel processors.pdf Kronos group Kronos group Nvidia OpenCL Best Practices Guide F. Sailhan (CNAM, département informatique) Introduction à la programmation massivement parallèle November 21, / 54