Différences

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

Lien vers cette vue comparative

Les deux révisions précédentes Révision précédente
Prochaine révision
Révision précédente
formation:insa2018gpu [2018/11/27 14:22]
equemene [Intégration et exploitation du code PKDGRAV3]
formation:insa2018gpu [2018/12/09 10:42] (Version actuelle)
equemene [Implémentation C/OpenCL]
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 ? ===== ===== 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 le modèle du circuit de GPU, dans son nom étendu.
   * Récupérez sur le web les informations suivantes pour chaque GPU :   * 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 base des coeurs de calcul
     * la fréquence de la mémoire     * la fréquence de la mémoire
Ligne 335: Ligne 335:
 ==== Exploitations de xGEMM  ==== ==== 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 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> <note warning>
Ligne 690: Ligne 690:
  
 <note warning> <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   * Repérez dans le programme source le **noyau** OpenCL réalisant le calcul
Ligne 777: Ligne 777:
  
 <note warning> <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   * Compilez le programme avec la ligne de compilation précisée ci-dessus
Ligne 797: Ligne 797:
 {{:​formation:​opencluster2_qpu1.png?​direct&​400|}} {{:​formation:​opencluster2_qpu1.png?​direct&​400|}}
  
-Il est assez intéressant que les implémentations ​GPU offrent quasiment la même performance. Par contre les GPU offrent une performance bien moindre (6x moins pour la GTX 1080 Ti et presque 30x moins pour la Quadro K420).+Il est assez intéressant que les implémentations ​CPU offrent quasiment la même performance. Par contre les GPU offrent une performance bien moindre (6x moins pour la GTX 1080 Ti et presque 30x moins pour la Quadro K420).
  
 Il est aussi intéressant qu'​étrange que le nombre de "​coups"​ à l'​intérieur du quadrant d'​exploration ne soit pas le même pour toutes les implémentations. C'est un artéfact lié à la multiplication du //RNG// par la constante pour le placer entre 0 et 1.  Il est aussi intéressant qu'​étrange que le nombre de "​coups"​ à l'​intérieur du quadrant d'​exploration ne soit pas le même pour toutes les implémentations. C'est un artéfact lié à la multiplication du //RNG// par la constante pour le placer entre 0 et 1. 
  
 <note warning> <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   * 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|}} {{:​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> <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   * 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 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 ​ ^ ^  Périphérique ​ ^  Durée ​ ^  Itops  ^  Inside ​ ^
Ligne 845: Ligne 845:
  
 <note warning> <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**   * Repérez les éléments de **durée**, **itops** et **inside**
   * Tracez l'​histogramme correspondant aux performances sur le modèle ci-dessus   * Tracez l'​histogramme correspondant aux performances sur le modèle ci-dessus
Ligne 872: Ligne 872:
  
 <note warning> <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   * Reprenez les expériences ci-dessus en précisant un calcul en double précision
Ligne 965: Ligne 965:
  
 <note warning> <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''​   * Editez le code source avec l'​outil ''​gedit''​
   * Identifiez l'​appel de la procédure principale OpenCL : ligne   * Identifiez l'​appel de la procédure principale OpenCL : ligne
Ligne 982: Ligne 982:
 === Exploitation du programme === === 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 :  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''​   * ''​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>​ <​code>​
 gnuplot gnuplot
Ligne 1003: Ligne 1003:
  
 <note warning> <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   * 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   * Exécutez le d'un PR=1 à un PR égal à 8x le nombre de coeurs physiques
Ligne 1009: Ligne 1009:
 </​note>​ </​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 python PiXPU.py -d 2 -b 3584 -e $((3584*8)) -s 128 -r 3 -i 100000000000
 </​code>​ </​code>​
Ligne 1019: Ligne 1019:
  
 <note warning> <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   * 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   * 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>​ 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. 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   * 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   * Exécutez le avec le PR optimal des //Blocks// en CUDA
Ligne 1055: Ligne 1055:
  
 <note warning> <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   * Tracez les résultats avec GNUplot
   * Quels sont les PR avec les performances les plus faibles ?   * Quels sont les PR avec les performances les plus faibles ?
Ligne 1169: Ligne 1169:
  
 <note warning> <note warning>
-Exercice # : étude du source de ''​NBody.py''​+Exercice #22 : étude du source de ''​NBody.py''​
   * Editez le programme avec gedit   * Editez le programme avec gedit
   * Identifiez le bloc de noyaux OpenCL : lignes   * Identifiez le bloc de noyaux OpenCL : lignes
Ligne 1195: Ligne 1195:
  
 <note warning> <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   * 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   * Ajoutez l'​option pour un calcul en 64 bits et réexécutez
Ligne 1220: Ligne 1220:
 {{ :​formation:​nbody_007.png?​400 |}} {{ :​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   * Exécutez le programme pour le meilleur des CPU sur 8192 particules
   * Appuyez sur ''​s''​ pour passer des positions aux vitesses   * Appuyez sur ''​s''​ pour passer des positions aux vitesses
Ligne 1244: Ligne 1244:
 ==== Intégration et exploitation du code Gromacs ==== ==== 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 :   * La documentation offre ceci :
     - récupérez le source     - récupérez le source
Ligne 1259: Ligne 1259:
 </​note>​ </​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 sur GPU (et CPU) ?
   * Quel ''​Elapsed Time''​ avez-vous pour l'​exécution uniquement sur CPU ?   * Quel ''​Elapsed Time''​ avez-vous pour l'​exécution uniquement sur CPU ?
Ligne 1269: Ligne 1269:
 ==== Intégration et exploitation du code PKDGRAV3 ==== ==== 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 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 :   * La documentation offre ceci :
     - récupérez le source     - 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''​. 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''​   * Passez dans le dossier ''​examples''​
   * Exécutez ''​pkdgrav3''​ sur ''​cosmology.par''​   * Exécutez ''​pkdgrav3''​ sur ''​cosmology.par''​
Ligne 1296: Ligne 1296:
 </​note>​ </​note>​
  
-Si vous rencontrez des difficultés ​sur la compilationet surtout ​l'exécution+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//  --- //​[[emmanuel.quemener@ens-lyon.fr|Emmanuel Quemener]] CC BY-NC-SA 2018/11/26 15:37//
formation/insa2018gpu.1543324954.txt.gz · Dernière modification: 2018/11/27 14:22 par equemene