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:42]
equemene
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 802: Ligne 802:
  
 <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>​
  
-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//  --- //​[[emmanuel.quemener@ens-lyon.fr|Emmanuel Quemener]] CC BY-NC-SA 2018/11/26 15:37//
formation/insa2018gpu.1543326127.txt.gz · Dernière modification: 2018/11/27 14:42 par equemene