formation:insa2018gpu

Différences

Ci-dessous, les différences entre deux révisions de la page.

--- formation:insa2018gpu [2018/11/27 13:42] – equemene
+++ formation:insa2018gpu [2018/12/09 09:42] (Version actuelle) – [Implémentation C/OpenCL] equemene
@@ Ligne 1: / Ligne 1: @@
-====== Session pratique du cours sur les GPU ======
+====== INSA 2018 : session pratique du cours sur les GPU ======
-Session pratique du [[http://www.cbp.ens-lyon.fr/emmanuel.quemener/documents/CoursINSA_GPU_181112.pdf|cours du 12/11/2018]] réalisé par Emmanuel Quémener.
+Cette session pratique accompagne le [[http://www.cbp.ens-lyon.fr/emmanuel.quemener/documents/CoursINSA_GPU_181112.pdf|cours du 12/11/2018]] réalisé par Emmanuel Quémener.
 ===== CQQCOQP : Comment ? Qui ? Quand ? Combien ? Où ? Quoi ? Pourquoi ? =====
@@ Ligne 73: / Ligne 73: @@
   * Récupérez le modèle du circuit de GPU, dans son nom étendu.
   * Récupérez sur le web les informations suivantes pour chaque GPU :
-    * le nombre d'unités de calcul (les "cudacores" ou les "streamprocessor")
+    * le nombre d'unités de calcul (les "cuda cores" ou les "stream processors")
     * la fréquence de base des coeurs de calcul
     * la fréquence de la mémoire
@@ Ligne 335: / Ligne 335: @@
 ==== Exploitations de xGEMM  ====
-Le dossier ''bench4gpu/xGEMM'' contient peu de fichiers dont les importants sont : un unique programme source, ''xGEMM.c'', et un fichier de construction, ''Makefile''. C'est ce fichier qui va ''construire'' tous les exécutables d'un coup, à la fois pour les différentes implémentations de BLAS, mais aussi pour les deux précisions **SP** (simple précision sur 32 bits) et **DP** (double précision sur 64 bits).
+Le dossier ''bench4gpu/BLAS/xGEMM'' contient peu de fichiers dont les importants sont : un unique programme source, ''xGEMM.c'', et un fichier de construction, ''Makefile''. C'est ce fichier qui va ''construire'' tous les exécutables d'un coup, à la fois pour les différentes implémentations de BLAS, mais aussi pour les deux précisions **SP** (simple précision sur 32 bits) et **DP** (double précision sur 64 bits).
 === Le source ===
-Le programme source ''xGEMM.c'' a été conçu pour être polyvalent pour toute implémentation. Si vous l'éditez, vous réalisez qu'il n'est pas si simple d'avoir un programme qui s'exécute indifféremment quelle que soit la librairie. Même si les appels sont comparables (même nombre d'attributs dans les fonctions), leur nom change de librairie à librairie. Pour n'avoir qu'un seul source, les directives sont largement exploitées. C'est donc le ''Makefile'' qui va permettre de ne compiler que telle ou telle portion du programme source.
+Le programme source ''xGEMM.c'' a été conçu pour fonctionner avec n'importe quelle implémentation. Si vous l'éditez, vous réalisez qu'il n'est pas si simple d'avoir un programme qui s'exécute indifféremment quelle que soit la librairie. Même si les appels sont comparables (même nombre d'attributs dans les fonctions), leur nom change de librairie à librairie. Pour n'avoir qu'un seul source, les directives sont largement exploitées. C'est donc le ''Makefile'' qui va permettre de ne compiler que telle ou telle portion du programme source.
 <note warning>
@@ Ligne 690: / Ligne 690: @@
 <note warning>
-**Exercice # : exploration du code OpenCL**
+**Exercice #11 : exploration du code OpenCL**
   * Repérez dans le programme source le **noyau** OpenCL réalisant le calcul
@@ Ligne 777: / Ligne 777: @@
 <note warning>
-**Exercice # : compilation et première exécution**
+**Exercice #12 : compilation et première exécution**
   * Compilez le programme avec la ligne de compilation précisée ci-dessus
@@ Ligne 802: / Ligne 802: @@
 <note warning>
-**Exercice # : exécution sur tous les périphériques pour un PR=1**
+**Exercice #13 : exécution sur tous les périphériques pour un PR=1**
   * Exécutez le programme sur tous (GPU & CPU) avec un nombre d'itérations de 1 milliard
@@ Ligne 821: / Ligne 821: @@
 {{:formation:opencluster2_qpu1024.png?direct&400|}}
-Cette seconde expérience montre de manière assez spectaculaire que les GPU ne montrent leur puissance "que" pour des régimes de parallélisme élevé. Notons aussi que les implémentations sur CPU ont des performances très très disparates.
+Cette seconde expérience montre de manière assez spectaculaire que les GPU ne dévoilent leur puissance "que" pour des régimes de parallélisme élevé. Notons aussi que les implémentations sur CPU ont des performances très très disparates.
 <note warning>
-**Exercice # : exécution sur tous les périphériques pour un PR=1024**
+**Exercice #14 : exécution sur tous les périphériques pour un PR=1024**
   * Exécutez le programme sur tous (GPU & CPU) avec un nombre d'itérations de 10 milliards
@@ Ligne 834: / Ligne 834: @@
 Dans l'expérience précédente, nous avons exploité un régime de parallélisme sur les processeurs très supérieur au nombre de //Compute Units//, lesquelles sont identifiées comme les coeurs. Il y avait 8 coeurs physiques et nous avons "chargé" chaque coeur à 256 fois leur charge. Que se passe-t-il si nous effectuons la même chose avec les GPU ?
-Dans notre exemple, la GTX 1080 Ti dispose de 3584 //cudacores//. La Quadro K420 de 192 //cudacores//. Explorons ces périphériques avec des  **PR** de 256x ces valeurs (nous sommes obligés de porter les itérations à 1000 milliards) :
+Dans notre exemple, la GTX 1080 Ti dispose de 3584 //cuda cores//. La Quadro K420 de 192 //cuda cores//. Explorons ces périphériques avec des  **PR** de 256x ces valeurs (nous sommes obligés de porter les itérations à 1000 milliards) :
 ^  Périphérique  ^  Durée  ^  Itops  ^  Inside  ^
@@ Ligne 845: / Ligne 845: @@
 <note warning>
-**Exercice # : exécution sur tous les périphériques pour un PR optimal**
+**Exercice #15 : exécution sur tous les périphériques pour un PR optimal**
-  * Reprenez les spécifications des GPU et isolez le nombre de //cudacores//
+  * Reprenez les spécifications des GPU et isolez le nombre de //cuda cores//
-  * Exécutez le programme sur les GPU avec un nombre d'itérations de 100 milliards et un PR de 256x le nombre de //cudacores//
+  * Exécutez le programme sur les GPU avec un nombre d'itérations de 100 milliards et un PR de 256x le nombre de //cuda cores//
   * Repérez les éléments de **durée**, **itops** et **inside**
   * Tracez l'histogramme correspondant aux performances sur le modèle ci-dessus
@@ Ligne 872: / Ligne 872: @@
 <note warning>
-**Exercice # : exécution sur tous les périphériques pour un PR optimal en double précision**
+**Exercice #16 : exécution sur tous les périphériques pour un PR optimal en double précision**
   * Reprenez les expériences ci-dessus en précisant un calcul en double précision
@@ Ligne 965: / Ligne 965: @@
 <note warning>
-Exercice # : récupération des éléments dans le code source
+Exercice #17 : récupération des éléments dans le code source
   * Editez le code source avec l'outil ''gedit''
   * Identifiez l'appel de la procédure principale OpenCL : ligne
@@ Ligne 982: / Ligne 982: @@
 === Exploitation du programme ===
-Ainsi, si nous voulons étudier la scalabilité du CPU en //Work items// de 1 à 16x le nombre de coeurs (ici 8 physiques) en exploitant l'implémentation AMD de OpenCL, nous appelons la commande : <code>python PiXPU.py -d 0 -b 1 -e $((8*16)) -r 10 -i 1000000000'' </code>
+Ainsi, si nous voulons étudier la scalabilité du CPU en //Work items// de 1 à 16x le nombre de coeurs (ici 8 physiques) en exploitant l'implémentation AMD de OpenCL, nous appelons la commande : <code>python PiXPU.py -d 0 -b 1 -e $((8*16)) -r 10 -i 1000000000 </code>
 Dans notre cas, nous avons les deux fichiers suivants à exploiter :
@@ Ligne 988: / Ligne 988: @@
   * ''Pi_FP32_MWC_xPU_OpenCL_1_128_1_1_1000000000_Device0_InMetro_opencluster2''
-Nous ppuvons ensuite exploiter l'outil simple ''gnuplot'' pour afficher nos résultats :
+Nous pouvons ensuite exploiter l'outil simple ''gnuplot'' pour afficher nos résultats :
 <code>
 gnuplot
@@ Ligne 1003: / Ligne 1003: @@
 <note warning>
-Exercice # : étude de la scalabilité d'une implémentation CPU
+Exercice #18 : étude de la scalabilité d'une implémentation CPU
   * Identifiez avec ''python PiXPU.py -h'' un périphérique CPU
   * Exécutez le d'un PR=1 à un PR égal à 8x le nombre de coeurs physiques
@@ Ligne 1009: / Ligne 1009: @@
 </note>
-Nous pouvons également "explorer" la scalabilité des GPU forts de notre expérience de ''PiOpenCL''. Par exemple, du nombre de //cudacores// à ce nombre multiplié par 16, par pas de 128. La commande appelée est la suivante :<code>
+Nous pouvons également "explorer" la scalabilité des GPU forts de notre expérience de ''PiOpenCL''. Par exemple, du nombre de //cuda cores// à ce nombre multiplié par 16, par pas de 128. La commande appelée est la suivante :<code>
 python PiXPU.py -d 2 -b 3584 -e $((3584*8)) -s 128 -r 3 -i 100000000000
 </code>
@@ Ligne 1019: / Ligne 1019: @@
 <note warning>
-Exercice # : étude de la scalabilité d'un GPU
+Exercice #19 : étude de la scalabilité d'un GPU
   * Identifiez avec ''python PiXPU.py -h'' un périphérique GPU
   * Exécutez-le d'un PR=<NbCudaCores> à un PR égal à 8x<NbCudaCores> par pas de 128 en OpenCL
@@ Ligne 1032: / Ligne 1032: @@
 La seule manière de retrouver une performance comparable en CUDA est de solliciter le second étage de parallélisme des GPU, les //Threads//. Avec la commande suivante, avec 1024 Threads, nous plafonnons à **198 Gitops** :<code>python PiXPU.py -g CUDA -d 0 -b $((3584*4)) -e $((3584*4)) -f 1024 -l 1024 -r 3 -i 1000000000000</code>
-Et ce n'est pas tout ! La distribtion Debian utilisée intègre par défaut un CUDA version 8. Pour l'intégration d'applications de //Deep Learning//, nous avons été obligé d'intégrer un CUDA version 9. Nous pouvons charger l'environnement pour exploiter cette version avec la commande :<code>module load cuda/9.0</code>
+Et ce n'est pas tout ! La distribution Debian utilisée intègre par défaut un CUDA version 8. Pour l'intégration d'applications de //Deep Learning//, nous avons été obligé d'intégrer un CUDA version 9. Nous pouvons charger l'environnement pour exploiter cette version avec la commande :<code>module load cuda/9.0</code>
 En relançant le calcul précédent, nous parvenons à **271 Gitops** soit plus que l'implémentation OpenCL.
-<note warning>Exercice # : étude de l'implémentation CUDA autour du PR optimal
+<note warning>Exercice #20 : étude de l'implémentation CUDA autour du PR optimal
   * Identifiez avec ''python PiXPU.py -h'' le périphérique GPU déjà utilisé en CUDA
   * Exécutez le avec le PR optimal des //Blocks// en CUDA
@@ Ligne 1055: / Ligne 1055: @@
 <note warning>
-Exercice # : étude de valeurs particulières de PR
+Exercice #21 : étude de valeurs particulières de PR
-  * Exécutez ''PiXPU.py'' autour du PR égal à 4x le nombre de //cudacores// (16 avant et 16 après)
+  * Exécutez ''PiXPU.py'' autour du PR égal à 4x le nombre de //cuda cores// (16 avant et 16 après)
   * Tracez les résultats avec GNUplot
   * Quels sont les PR avec les performances les plus faibles ?
@@ Ligne 1169: / Ligne 1169: @@
 <note warning>
-Exercice # : étude du source de ''NBody.py''
+Exercice #22 : étude du source de ''NBody.py''
   * Editez le programme avec gedit
   * Identifiez le bloc de noyaux OpenCL : lignes
@@ Ligne 1195: / Ligne 1195: @@
 <note warning>
-Exercice # : lancement de ''NBody.py'' pour 32768 particules
+Exercice #23 : lancement de ''NBody.py'' pour 32768 particules
   * Exécutez le programme pour tous les périphériques détectés
   * Ajoutez l'option pour un calcul en 64 bits et réexécutez
@@ Ligne 1220: / Ligne 1220: @@
 {{ :formation:nbody_007.png?400 |}}
-<note warning>Exercice # : lancement de ''NBody.py'' en mode ''-g''
+<note warning>Exercice #24 : lancement de ''NBody.py'' en mode ''-g''
   * Exécutez le programme pour le meilleur des CPU sur 8192 particules
   * Appuyez sur ''s'' pour passer des positions aux vitesses
@@ Ligne 1244: / Ligne 1244: @@
 ==== Intégration et exploitation du code Gromacs ====
-Nous allons, dans l'exercice suivant, tenter de reproduire une [[https://www.nvidia.com/en-us/data-center/gpu-accelerated-applications/gromacs/|expérience de Nvidia]] vantant l'efficacité des GPGPU pour le logiciel de [[https://fr.wikipedia.org/wiki/Dynamique_mol%C3%A9culaire|dynamique moléculaire]] [[http://www.gromacs.org/|Gromacs]].
+Nous allons tenter de reproduire une [[https://www.nvidia.com/en-us/data-center/gpu-accelerated-applications/gromacs/|expérience de Nvidia]] vantant l'efficacité des GPGPU pour le logiciel de [[https://fr.wikipedia.org/wiki/Dynamique_mol%C3%A9culaire|dynamique moléculaire]] [[http://www.gromacs.org/|Gromacs]].
-<note warning>Exercice # : appliquez la "recette" de Nvidia
+<note warning>Exercice #25 : appliquez la "recette" de Nvidia
   * La documentation offre ceci :
     - récupérez le source
@@ Ligne 1259: / Ligne 1259: @@
 </note>
-En cas de difficultés, appliquez la [[formation:insa2018gpu:insa2018gromacs4stretch|recette de Gromacs pour Debian Stretch]].
+En cas de difficultés, appliquez la [[formation:insa2018gpu:insa2018gromacs4stretch|recette de Gromacs pour Debian Stretch]] ;-)
-<note warning>Exécutez l'exemple ''1536''
+<note warning>Exercice #26 : Exécutez l'exemple ''1536''
   * Quel ''Elapsed Time'' avez-vous pour l'exécution sur GPU (et CPU) ?
   * Quel ''Elapsed Time'' avez-vous pour l'exécution uniquement sur CPU ?
@@ Ligne 1269: / Ligne 1269: @@
 ==== Intégration et exploitation du code PKDGRAV3 ====
-Le code PKDGRAV3 est une logiciel de simulation hydrodynamique à la large couverture médiatique en juin 2017. Présenté comme exploitant massivement les GPU, il est disponible sur [[https://bitbucket.org/dpotter/pkdgrav3/|bitbucket]].
+Le code PKDGRAV3 est un logiciel de simulation hydrodynamique à la large couverture médiatique en juin 2017. Présenté comme exploitant massivement les GPU, il est disponible sur [[https://bitbucket.org/dpotter/pkdgrav3/|bitbucket]].
 Le code source est accessible par ''git'' à l'adresse : https://bitbucket.org/dpotter/pkdgrav3.git
-<note warning>Récupérez et compilez le code suivant la documentation fournie
+<note warning>Exercice #27 : Récupérez et compilez le code suivant la documentation fournie
   * La documentation offre ceci :
     - récupérez le source
@@ Ligne 1290: / Ligne 1290: @@
 L'exécution du programme s'effectue en associant l'exécutable ''pkdgrav3'' au fichier de paramètres ''cosmology.par'' dans le dossiers ''examples''.
-<note warning>Exécutez l'exemple ''cosmology.par''
+<note warning>Exercice #28 : Exécutez l'exemple ''cosmology.par''
   * Passez dans le dossier ''examples''
   * Exécutez ''pkdgrav3'' sur ''cosmology.par''
@@ Ligne 1296: / Ligne 1296: @@
 </note>
-En cas de difficultés, appliquez la [[formation:insa2018gpu:insa2018pkdgrav4stretch|recette d'un PKDGRAV3 pour Debian Stretch]].
+En cas de difficultés, appliquez la [[formation:insa2018gpu:insa2018pkdgrav4stretch|recette d'un PKDGRAV3 pour Debian Stretch]] ;-)
+===== Conclusion =====
+Comme vous l'aurez remarqué au cours de ces Travaux Pratiques, l'exploitation peut être pleine de surprises : une métrologie pertinente ne peut se passer de la connaissance du matériel exploité.
+L'exploitation de "codes métier" vous aura aussi permis d'entrevoir la difficulté d'intégrer et d'exécuter des programmes dans des environnements pourtant bien homogènes : toutes les stations exploitées ont exactement le même système d'exploitation, [[developpement:productions:SIDUS|SIDUS]]. Les "astuces" permettant de simplement pouvoir exécuter les programmes illustraient aussi que, sans expérience, difficile de s'en sortir.
  --- //[[emmanuel.quemener@ens-lyon.fr|Emmanuel Quemener]] CC BY-NC-SA 2018/11/26 15:37//

formation/insa2018gpu.1543326127.txt.gz · Dernière modification : 2025/05/14 07:39 (modification externe)

Rechercher

Translations

Piste :

toolbox