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:etsn2022gpu [2022/07/21 11:05]
equemene
formation:etsn2022gpu [2022/08/12 11:35] (Version actuelle)
equemene [Prérequis en matériel, logiciel et humain]
Ligne 1: Ligne 1:
 ====== ETSN 2022 : les GPU, la technologie disruptive du 21ème siècle ====== ====== ETSN 2022 : les GPU, la technologie disruptive du 21ème siècle ======
  
-<note warning>En construction</​note>​+<note warning>Contient certainement encore un nombre non négligeable de coquilles... Merci de votre compréhension. Mon adresse de courriel est en bas pour vous permettre d'en assurer l'​amélioration !</​note>​
  
-Cette session de travaux pratiques se compose de 7 séances de 1h30 du workshop [[https://​conferences.cirm-math.fr/​2842.html|Les GPU, technologie disruptive du 21ème siècle]]. Elle s'​accompagne de 5 cours donnés par Emmanuel Quémener.+Cette session de travaux pratiques se compose de 7 séances de 1h30 du workshop [[https://​conferences.cirm-math.fr/​2842.html|Les GPU, technologie disruptive du 21ème siècle]]. Elle s'​accompagne de 5 cours suivants ​donnés par Emmanuel Quémener. 
 + 
 +    * Cours 1 & 2 : [[http://​www.cbp.ens-lyon.fr/​emmanuel.quemener/​documents/​ETSN_IntroductionGPU_Cours12.pdf|Les GPU : technologie disruptive du 21e siècle]] 
 +    * Cours 3 : [[http://​www.cbp.ens-lyon.fr/​emmanuel.quemener/​documents/​ETSN_PortageEtMetrologie_Cours3.pdf|Portage d'un vieux code, l'​occasion d'un retour sur 40 ans d'​informatique]] 
 +    * Cours 4 : [[http://​www.cbp.ens-lyon.fr/​emmanuel.quemener/​documents/​ETSN_MetrologieGPU_Cours4.pdf|Métrologie d'​applications]] 
 +    * Cours 5 : [[http://​www.cbp.ens-lyon.fr/​emmanuel.quemener/​documents/​ETSN_CodesMatrices_Cours5.pdf|Emergence de Codes "​Matrices"​ et conclusion]]
  
 ===== CQQCOQP : Comment ? Qui ? Quand ? Combien ? Où ? Quoi ? Pourquoi ? ===== ===== CQQCOQP : Comment ? Qui ? Quand ? Combien ? Où ? Quoi ? Pourquoi ? =====
Ligne 28: Ligne 33:
   * Un intermède Python/CUDA pour tester //​l'​autre//​ implémentation sur GPU   * Un intermède Python/CUDA pour tester //​l'​autre//​ implémentation sur GPU
   * La réalisation et le portage d'une transformée de Fourier discrète   * La réalisation et le portage d'une transformée de Fourier discrète
-  * Choix du périphérique en Pythonsa programmation +  * Choix du périphérique en Python ​et sa programmation 
-  * Utilisation des librairies externesexemple avec xGEMM+  * Utilisation des librairies externes ​exemple avec xGEMM
   * Intégration de "codes métier"​ : [[https://​www.tensorflow.org/​|TensorFlow]],​ [[https://​www.r-ccs.riken.jp/​labs/​cbrt/​|GENESIS]] et [[http://​www.gromacs.org/​|Gromacs]]   * Intégration de "codes métier"​ : [[https://​www.tensorflow.org/​|TensorFlow]],​ [[https://​www.r-ccs.riken.jp/​labs/​cbrt/​|GENESIS]] et [[http://​www.gromacs.org/​|Gromacs]]
   * Expoitation de codes //​Matrices//​ pour la métrologie ​   * Expoitation de codes //​Matrices//​ pour la métrologie ​
Ligne 48: Ligne 53:
 === Prérequis pour le logiciel === === Prérequis pour le logiciel ===
  
-  * Si vous n'​utilisez pas le CBP, un OS GNU/Linux correctement configuré pour la GPU embarquée avec tous les composants Nvidia, OpenCL, PyOpenCL, PyCUDA. A cela s'​ajoute un navigateur pour voir cette page ainsi qu'un traitement de texte pour rédiger le compte-rendu de ces séances.+  * Si vous n'​utilisez pas le CBP, un OS GNU/Linux correctement configuré pour la GPU embarquée avec tous les composants Nvidia, OpenCL, PyOpenCL, PyCUDA
 +    * Un ''​apt install time pciutils clinfo nvidia-opencl-icd nvidia-smi pocl-opencl-icd python3-pyopencl python-pyopencl-doc python-pycuda-doc python3-pycuda''​ devrait être suffisant comme prérequis pour une machine avec un circuit Nvidia pas trop ancien 
 +    * Pour les implémentations OpenCL sur CPU sur Debian ou Ubuntu, essayez d'​installer celle d'​[[http://​www.cbp.ens-lyon.fr/​emmanuel.quemener/​software/​opencl-1.2-intel-cpu_6.4.0.25-2_amd64.deb|Intel]] et celle d'​[[http://​www.cbp.ens-lyon.fr/​emmanuel.quemener/​software/​amd-opencl-icd_15.12-2~bpo8+3_fixed.deb|AMD]]. A votre environnement ​s'​ajoute un navigateur pour voir cette page ainsi qu'un traitement de texte pour rédiger le compte-rendu de ces séances. ​
   * Si vous utilisez le CBP, il faut avoir installé le logiciel [[https://​wiki.x2go.org/​doku.php/​download:​start|x2goclient]] suivant les recommandations de la [[ressources:​x2go4cbp|documentation du CBP]]. Il est recommandé d'​exploiter le traitement de texte et le navigateur dans la session distante.   * Si vous utilisez le CBP, il faut avoir installé le logiciel [[https://​wiki.x2go.org/​doku.php/​download:​start|x2goclient]] suivant les recommandations de la [[ressources:​x2go4cbp|documentation du CBP]]. Il est recommandé d'​exploiter le traitement de texte et le navigateur dans la session distante.
  
Ligne 69: Ligne 76:
   * Input and Output Devices : Périphériques d'​Entrée et Sortie   * Input and Output Devices : Périphériques d'​Entrée et Sortie
  
-Les GPU sont généralement considérés comme des périphériques d'​Entrée/​Sortie. Comme la plupart des périphériques installés dans les machines, ​ils exploitent un bus d'​interconnexion [[https://​en.wikipedia.org/​wiki/​Conventional_PCI|PCI]] ou [[https://​en.wikipedia.org/​wiki/​PCI_Express|PCI Express]].+Les GPU sont généralement considérés comme des périphériques d'​Entrée/​Sortie. Comme la plupart des périphériques installés dans les machines, ​elles exploitent un bus d'​interconnexion [[https://​en.wikipedia.org/​wiki/​Conventional_PCI|PCI]] ou [[https://​en.wikipedia.org/​wiki/​PCI_Express|PCI Express]].
  
 Pour récupérer la liste des périphériques PCI, utilisez la commande ''​lspci -nn''​. A l'​intérieur d'une longue liste apparaissent quelques périphériques **VGA** ou **3D**. Ce sont les périphériques GPU ou GPGPU. Pour récupérer la liste des périphériques PCI, utilisez la commande ''​lspci -nn''​. A l'​intérieur d'une longue liste apparaissent quelques périphériques **VGA** ou **3D**. Ce sont les périphériques GPU ou GPGPU.
Ligne 204: Ligne 211:
   * ses puissances : instantanée et maximale   * ses puissances : instantanée et maximale
   * ses "​occupations"​ mémoire : instantanée et maximale   * ses "​occupations"​ mémoire : instantanée et maximale
-  * les processus les exploitant, leur consommation de mémoire et le GPU associé+  * les processus les exploitant, leur consommation de mémoire et la GPU associée
  
 <note warning> <note warning>
Ligne 351: Ligne 358:
 La (presque) totalité des outils exploités par le CBP pour comparer les CPU et les GPU se trouve dans le projet [[https://​forge.cbp.ens-lyon.fr/​redmine/​projects/​bench4gpu|bench4gpu]] du Centre Blaise Pascal. La (presque) totalité des outils exploités par le CBP pour comparer les CPU et les GPU se trouve dans le projet [[https://​forge.cbp.ens-lyon.fr/​redmine/​projects/​bench4gpu|bench4gpu]] du Centre Blaise Pascal.
  
-La récupération des sources est libre et se réalise par l'​outil subversion :<​code>​+La récupération des sources est libre et se réalise par l'​outil ​**subversion** (//NDLR : oui, je sais tout le monde est passé à GIT mais ce projet a plus de 10 ans//​) ​:<​code>​
 svn checkout https://​forge.cbp.ens-lyon.fr/​svn/​bench4gpu/​ svn checkout https://​forge.cbp.ens-lyon.fr/​svn/​bench4gpu/​
 </​code>​ </​code>​
Ligne 366: Ligne 373:
   * ''​ETSN''​ : les programmes //​corrigés//​ associés à cette école ETSN 2022   * ''​ETSN''​ : les programmes //​corrigés//​ associés à cette école ETSN 2022
  
-De tous ces programmes, seuls ceux présents dans ''​BLAS'',​ ''​NBody'',​ ''​Pi''​ et ''​ETSN''​ seront exploités dans le cadre de ces travaux pratiques. Il est quand même conseillé de ne pas se précipiter sur les corrigés situés dans ETSN pour le déroulement de ces séances. Le //no pain, no gain// s'​applique aussi dans l'​apprentissage en informatique.+De tous ces programmes, seuls ceux présents dans ''​BLAS'',​ ''​NBody'',​ ''​Pi''​ et ''​ETSN''​ seront exploités dans le cadre de ces travaux pratiques. Il est quand même conseillé de ne pas se précipiter sur les corrigés situés dans ETSN pour le déroulement de ces séances. Le //no pain, no gain// s'​applique ​//aussi// dans l'​apprentissage en informatique.
  
 ===== Première exploration de l'​association Python et OpenCL ===== ===== Première exploration de l'​association Python et OpenCL =====
Ligne 483: Ligne 490:
   - une estimation de la vitesse d'​exécution en OpenCL pour différentes tailles   - une estimation de la vitesse d'​exécution en OpenCL pour différentes tailles
   - un ratio de performances entre mode natif et mode OpenCL   - un ratio de performances entre mode natif et mode OpenCL
 +  - la libération des mémoires réservées dans le bloc ''​OpenCLAddition''​
  
 Deux exécutions consécutives sur GPU et CPU permettront ainsi de visualiser le gain entre une exécution sur CPU et GPU. Deux exécutions consécutives sur GPU et CPU permettront ainsi de visualiser le gain entre une exécution sur CPU et GPU.
Ligne 489: Ligne 497:
  
 Le temps d'​exécution se basera sur un mécanisme très simple : l'​exploitation de 2 //timers//, le premier avant l'​exécution,​ le second après l'​exécution. Ce //timer// est la fonction ''​time()''​ de la librairie standard ''​time''​. ​ Le temps d'​exécution se basera sur un mécanisme très simple : l'​exploitation de 2 //timers//, le premier avant l'​exécution,​ le second après l'​exécution. Ce //timer// est la fonction ''​time()''​ de la librairie standard ''​time''​. ​
 +
 +Pour libérer l'​espace réservé sur le périphérique avec les opérations ''​Buffer'',​ il suffit d'​appeler la fonction ''​.release()''​ en suffixe de la variable. ​
  
 Par exemple, à la commande ''​PYOPENCL_CTX=0:​0 ./​MySteps_1.py 1048576'',​ l'​exécution répond :<​code> ​ Par exemple, à la commande ''​PYOPENCL_CTX=0:​0 ./​MySteps_1.py 1048576'',​ l'​exécution répond :<​code> ​
Ligne 508: Ligne 518:
  
 <note warning>​**Exercice #2.3 : instrumentation minimale du code** <note warning>​**Exercice #2.3 : instrumentation minimale du code**
-  - Modifiez ''​MySteps_1.py''​ suivant les spécifications ci-dessus+  - Modifiez ''​MySteps_1.py''​ suivant les spécifications ci-dessus
   - Exécutez le programme pour des tailles de vecteurs de **2^15** à **2^30**   - Exécutez le programme pour des tailles de vecteurs de **2^15** à **2^30**
-    - sur le GPU le plus //performant//+    - sur la GPU la plus //performante//
     - sur l'​implémentation CPU la plus //​efficace//​ : l'​Intel     - sur l'​implémentation CPU la plus //​efficace//​ : l'​Intel
   - Analysez dans quelles situations des problèmes de produisent :   - Analysez dans quelles situations des problèmes de produisent :
Ligne 551: Ligne 561:
 </​code>​ </​code>​
  
-Son origine était assez explicite avec le **MEM_OBJECT_ALLOCATION_FAILURE** renseignant sur un problème mémoire ou plus précisément sur un dépassement de capacité d'​allocation mémoire sur le périphérique. Dans cet exemple, la GPU sélectionnée est une **GTX Titan** avec 6GB de RAM. Notre programme planet dès que la taille des vecteurs dépasse 2^29 éléments soit 536870912. Si nous définissons 3 vecteurs composés de 536870912 flottants sur 32 bits, cela représente tout juste 6 GiB mais la GPU ne dispose que d'​exactement 6083 MiB. Il en manque à peine, mais il en manque !+Son origine était assez explicite avec le **MEM_OBJECT_ALLOCATION_FAILURE** renseignant sur un problème mémoire ou plus précisément sur un dépassement de capacité d'​allocation mémoire sur le périphérique. Dans cet exemple, la GPU sélectionnée est une **GTX Titan** avec 6GB de RAM. Notre programme planet dès que la taille des vecteurs dépasse 2^29 éléments soit 536870912. Si nous définissons 3 vecteurs composés de 536870912 flottants sur 32 bits, cela représente tout juste 6 GiB mais la GPU ne dispose que d'​exactement 6083 MiB. Il en manque à peine, mais il en manque ​suffisamment ​!
  
 Pour la CPU en implémentation Intel : Pour la CPU en implémentation Intel :
Ligne 682: Ligne 692:
 ^  33554432| ​ 1474004| ​ 22517796| ​ 15.276618| ^  33554432| ​ 1474004| ​ 22517796| ​ 15.276618|
  
-Nous constatons que le gain du passage en OpenCL est significatif,​ autant sur CPU que sur GPU, si la taille des objets approche le million. Nous avons une accélération de 15 pour le CPU et de 35 sur le GPU. En augmentant la charge très significativement (par exemple en n'​appelant pas seulement une fois ''​MySillyFunction''​ mais 4 fois à la suite, le gain sur CPU passe à 21 tandis qu'il dépasse les 127 sur ce GPU !+Nous constatons que le gain du passage en OpenCL est significatif,​ autant sur CPU que sur GPU, si la taille des objets approche le million. Nous avons une accélération de 15 pour le CPU et de 35 sur GPU. En augmentant la charge très significativement (par exemple en n'​appelant pas seulement une fois ''​MySillyFunction''​ mais 4 fois à la suite, le gain sur CPU passe à 21 tandis qu'il dépasse les 127 sur cette GPU !
  
 De plus, quand nous regardons les durées d'​exécution des noyaux en OpenCL, elles sont //presque// marginales. Ainsi, pour qu'une exécution OpenCL soit //​efficace//,​ il faudra veiller à ce que le temps d'​exécution soit bien supérieur aux autres durées telles que les transferts de données entre hôte et périphérique ou l'​initialisation du périphérique de calcul. Le programme ''​PiXPU.py''​ illustre de manière parfaite cet équilibre à établir sur le nombre de tâches concurrentielles à lancer et la //​profondeur calculatoire//​ (ou l'//​intensité arithmétique//​) de chaque noyau. De plus, quand nous regardons les durées d'​exécution des noyaux en OpenCL, elles sont //presque// marginales. Ainsi, pour qu'une exécution OpenCL soit //​efficace//,​ il faudra veiller à ce que le temps d'​exécution soit bien supérieur aux autres durées telles que les transferts de données entre hôte et périphérique ou l'​initialisation du périphérique de calcul. Le programme ''​PiXPU.py''​ illustre de manière parfaite cet équilibre à établir sur le nombre de tâches concurrentielles à lancer et la //​profondeur calculatoire//​ (ou l'//​intensité arithmétique//​) de chaque noyau.
Ligne 1078: Ligne 1088:
 ^  65536| ​ 221|  1214|  11162| ​ 13446|  ​ ^  65536| ​ 221|  1214|  11162| ​ 13446|  ​
  
-Dans ce cas, CUDA est toujours plus performant que OpenCL mais la contrainte reste de pouvoir exploiter efficacement ces deux étages de parallélisme. Cette différence d'​efficacité n'est pas systématique : nous réalisons d'​abord qu'​elle dépend du système considéré mais cela va également complètement dépendre de l'​architecture interne ​du GPU, donc sa génération,​ son nombre de coeurs CUDA, sa mémoire, etc... ​+Dans ce cas, CUDA est toujours plus performant que OpenCL mais la contrainte reste de pouvoir exploiter efficacement ces deux étages de parallélisme. Cette différence d'​efficacité n'est pas systématique : nous réalisons d'​abord qu'​elle dépend du système considéré mais cela va également complètement dépendre de l'​architecture interne ​de la GPU, donc sa génération,​ son nombre de coeurs CUDA, sa mémoire, etc... ​
  
 L'​exemple précédent était exécuté sur une **GTX Titan** avec circuit Kepler datant de 2013.  L'​exemple précédent était exécuté sur une **GTX Titan** avec circuit Kepler datant de 2013. 
Ligne 1112: Ligne 1122:
 Les méthodes présentées dans la suite ont l'​avantage d'​être systématiques et donc pourront être exploitées dans n'​importe quel programme PyOpenCL pour PyCUDA. Les méthodes présentées dans la suite ont l'​avantage d'​être systématiques et donc pourront être exploitées dans n'​importe quel programme PyOpenCL pour PyCUDA.
  
-A cela s'​ajoute également la possibilité d'​ajouter des options au lancement du programme, notamment pour spécifier ​son GPU. Dans les programmes de l'​archive **bench4gpu** en Python, la majorité dispose d'une option ''​-h''​ permettant de voir les options ainsi que de lister les périphériques OpenCL ou CUDA détectés.+A cela s'​ajoute également la possibilité d'​ajouter des options au lancement du programme, notamment pour spécifier ​sa GPU. Dans les programmes de l'​archive **bench4gpu** en Python, la majorité dispose d'une option ''​-h''​ permettant de voir les options ainsi que de lister les périphériques OpenCL ou CUDA détectés.
  
 L'​objectif est donc de reprendre notre exemple le plus abouti de notre DFT et d'y ajouter ces éléments. Pour cela, les programmes ''​PiXPU.py''​ et ''​TrouNoir.py''​ vont être explorés pour voir comment faire. L'​objectif est donc de reprendre notre exemple le plus abouti de notre DFT et d'y ajouter ces éléments. Pour cela, les programmes ''​PiXPU.py''​ et ''​TrouNoir.py''​ vont être explorés pour voir comment faire.
Ligne 1181: Ligne 1191:
   - Modifiez la fonction ''​OpenCLDFT''​ sur la base de fonction ''​MetropolisOpenCL''​ de ''​PiXPU.py''​   - Modifiez la fonction ''​OpenCLDFT''​ sur la base de fonction ''​MetropolisOpenCL''​ de ''​PiXPU.py''​
   - Exécutez le programme par défaut (sans option)   - Exécutez le programme par défaut (sans option)
-  - Exécutez le programme sur le second ​GPU+  - Exécutez le programme sur la seconde ​GPU
 </​note>​ </​note>​
  
Ligne 1205: Ligne 1215:
 </​code>​ </​code>​
  
-Pour une sollicitation ​du second ​GPU, la performance est moindre et c'est normal. ​Le GPU **Quadro K420** est très inférieur ​en performance à la **GTX Titan**.+Pour une sollicitation ​de la seconde ​GPU, la performance est moindre et c'est normal. ​La GPU **Quadro K420** est très inférieure ​en performance à la **GTX Titan**.
 <​code>​ <​code>​
 Device Selection : 1 Device Selection : 1
Ligne 1256: Ligne 1266:
     * rajouter la ligne ''​Context.detach()''​ ensuite     * rajouter la ligne ''​Context.detach()''​ ensuite
   - Exécutez le programme avec l'​option ''​-g CUDA''​   - Exécutez le programme avec l'​option ''​-g CUDA''​
-  - Exécutez le programme en sélectionnant ​le second ​GPU+  - Exécutez le programme en sélectionnant ​la seconde ​GPU
 </​note>​ </​note>​
  
Ligne 1309: Ligne 1319:
 </​code>​ </​code>​
  
-En lisant attentivement,​ nous découvrons que le compilateur **nvcc** embarqué ne supporte pas la GPU **Quadro K420** simplement parce qu'​elle est trop vieille ! Ainsi, **PyOpenCL** montre là aussi sa supériorité : non seulement PyOpenCL permet une exécution sans modification sur CPU ou GPU, de manière plus efficace qu'​avec Numpy ou Numba, mais en plus, sur GPU, elle offre moins de contraintes sur la distribution des tâches (pas de nécessité d'//​hybrider//​ son programme en //Blocks// et //​Threads//​) et une pérennité dans le temps, que ce soit pour les GPU très anciens ​ou très récents ​!+En lisant attentivement,​ nous découvrons que le compilateur **nvcc** embarqué ne supporte pas la GPU **Quadro K420** simplement parce qu'​elle est trop vieille ! Ainsi, **PyOpenCL** montre là aussi sa supériorité : non seulement PyOpenCL permet une exécution sans modification sur CPU ou GPU, de manière plus efficace qu'​avec Numpy ou Numba, mais en plus, sur GPU, elle offre moins de contraintes sur la distribution des tâches (pas de nécessité d'//​hybrider//​ son programme en //Blocks// et //​Threads//​) et une pérennité dans le temps, que ce soit pour les GPU très anciennes ​ou très récentes ​!
  
 Comme dernière modification sur notre , nous proposons de : Comme dernière modification sur notre , nous proposons de :
Ligne 1498: Ligne 1508:
 Nous voyons que le GPU #0, identifié comme la GTX 1080 Ti, exécute 2 tâches : ''/​usr/​lib/​xorg/​Xorg''​ et ''​./​xGEMM_SP_cublas''​. Nous avons également l'​empreinte mémoire de chacun des processus : 36MiB pour le ''​Xorg''​ et 199MiB pour notre programme ''​xGEMM_SP_cublas''​. ​ Nous voyons que le GPU #0, identifié comme la GTX 1080 Ti, exécute 2 tâches : ''/​usr/​lib/​xorg/​Xorg''​ et ''​./​xGEMM_SP_cublas''​. Nous avons également l'​empreinte mémoire de chacun des processus : 36MiB pour le ''​Xorg''​ et 199MiB pour notre programme ''​xGEMM_SP_cublas''​. ​
  
-La question légitime est de se demander, dans le cas d'une machine multi-gpu, comment "​contrôler"​ sur quel GPU est exécuté ​le programme. Il existe des méthodes assez comparables à celles de OpenCL pour la découverte des périphériques,​ mais elles sont généralement peu exploitées dans les programmes. La technique la plus classique reste l'​utilisation d'une variable d'​environnement,​ laquelle va "​contraindre"​ l'​exploitation d'un (ou plusieurs) GPU(s) : ''​CUDA_VISIBLE_DEVICES''​.+La question légitime est de se demander, dans le cas d'une machine multi-gpu, comment "​contrôler"​ sur quele GPU est exécutée ​le programme. Il existe des méthodes assez comparables à celles de OpenCL pour la découverte des périphériques,​ mais elles sont généralement peu exploitées dans les programmes. La technique la plus classique reste l'​utilisation d'une variable d'​environnement,​ laquelle va "​contraindre"​ l'​exploitation d'un (ou plusieurs) GPU(s) : ''​CUDA_VISIBLE_DEVICES''​.
  
 Par exemple, si nous précisons que cette variable vaut ''​1'',​ le périphérique Nvidia ''#​1''​ sera le seul sollicité. Ainsi, en lançant la commande préfixée de cette variable valuée, nous avons : Par exemple, si nous précisons que cette variable vaut ''​1'',​ le périphérique Nvidia ''#​1''​ sera le seul sollicité. Ainsi, en lançant la commande préfixée de cette variable valuée, nous avons :
Ligne 1663: Ligne 1673:
 Nous allons tenter d'​exploiter un des exemples présentés dans les [[https://​www.tensorflow.org/​tutorials|tutoriels]] de [[https://​www.tensorflow.org/​|TensorFlow]]. Nous allons tenter d'​exploiter un des exemples présentés dans les [[https://​www.tensorflow.org/​tutorials|tutoriels]] de [[https://​www.tensorflow.org/​|TensorFlow]].
  
-L'​exploitation des GPU a littéralement "​explosé"​ lorsque le //Machine Learning// ou le //Deep Learning// sont devenus des modes. En effet, la puissance "​brute"​ des GPU peut enfin être exploitée sans trop de portage, notamment par l'​exploitation des librairies BLAS.+L'​exploitation des GPU a littéralement "​explosé"​ lorsque le //Machine Learning// ou le //Deep Learning// sont devenus des modes. En effet, la puissance "​brute"​ des GPU peut enfin être exploitée sans trop de portage, notamment par l'​exploitation des librairies BLAS ou cuDNN.
  
-L'​exemple sur lequel nous allons nous pencher est le [[https://​www.tensorflow.org/​tutorials/​images/​deep_cnn|DeepCNN]].+L'​exemple sur lequel nous allons nous pencher est le [[https://​www.tensorflow.org/​tutorials/​images/​cnn|DeepCNN]].
  
 L'​intégration de TensorFlow avec une exploitation des GPU est plutôt ardue à partir des sources, étant donné le nombre de dépendances. L'​approche [[https://​docs.conda.io/​en/​latest/​|Conda]] permet d'​installer un "​environnement système"​ bâti essentiellement autour d'​applications Python. Conda permet également à tout utilisateur de créer son propre environnement complet lui permettant un suivi personnel de ses outils. L'​intégration de TensorFlow avec une exploitation des GPU est plutôt ardue à partir des sources, étant donné le nombre de dépendances. L'​approche [[https://​docs.conda.io/​en/​latest/​|Conda]] permet d'​installer un "​environnement système"​ bâti essentiellement autour d'​applications Python. Conda permet également à tout utilisateur de créer son propre environnement complet lui permettant un suivi personnel de ses outils.
Ligne 1680: Ligne 1690:
   - préparez la variable d'​environnement ''​TIME''​   - préparez la variable d'​environnement ''​TIME''​
   - ouvrez un terminal et tapez ''​dstat''​ pour monitorer le système   - ouvrez un terminal et tapez ''​dstat''​ pour monitorer le système
-  - ouvrez un terminal et tapez ''​nvidia-smi dmon''​ pour le GPU+  - ouvrez un terminal et tapez ''​nvidia-smi dmon''​ pour la GPU
   - lancez un ''​ipython''​ dans un terminal   - lancez un ''​ipython''​ dans un terminal
   - appliquez ligne à ligne le tutoriel et regardez l'​activité réseau   - appliquez ligne à ligne le tutoriel et regardez l'​activité réseau
Ligne 1692: Ligne 1702:
   - inhibez les GPU Nvidia avec ''​CUDA_VISIBLE_DEVICES''​   - inhibez les GPU Nvidia avec ''​CUDA_VISIBLE_DEVICES''​
   - relancez le fichier préfixé de ''/​usr/​bin/​time python''​   - relancez le fichier préfixé de ''/​usr/​bin/​time python''​
-  - vérifiez que le GPU est inutilisé+  - vérifiez que la GPU est inutilisée
   - notez le temps écoulé (''​TIME Elapsed''​) pour cette troisième exécution   - notez le temps écoulé (''​TIME Elapsed''​) pour cette troisième exécution
-  - comparez les temps d'​exécution et sur l'​efficacité d'​usage ​du GPU+  - comparez les temps d'​exécution et sur l'​efficacité d'​usage ​de la GPU
 </​note>​ </​note>​
  
-En regardant l'​activité du GPU, il apparaît que le gain est substanciel par rapport à une "​petite"​ configuration GPU. Cependant, la nature du réseau créé n'​exploitait pas de manière optimale ​le GPU par rapport ​au CPU. Une petite modification de notre réseau va permettre de mettre cela en évidence, en modifiant le nombre de poids d'une des couches neuronales.+En regardant l'​activité du GPU, il apparaît que le gain est substanciel par rapport à une "​petite"​ configuration GPU. Cependant, la nature du réseau créé n'​exploitait pas de manière optimale ​la GPU par rapport ​à la CPU. Une petite modification de notre réseau va permettre de mettre cela en évidence, en modifiant le nombre de poids d'une des couches neuronales.
  
 <note warning>​**Exercice #7.2 :** <note warning>​**Exercice #7.2 :**
Ligne 1704: Ligne 1714:
   - relancez l'​apprentissage ''/​usr/​bin/​time python CIFAR10.py''​   - relancez l'​apprentissage ''/​usr/​bin/​time python CIFAR10.py''​
   - notez dès le début d'un cycle l'ETA (Estimate Time of Arrival) ​   - notez dès le début d'un cycle l'ETA (Estimate Time of Arrival) ​
-  - contrôlez l'​activité ​du GPU+  - contrôlez l'​activité ​de la GPU
   - arrêtez l'​apprentissage avec un **<​Ctrl><​C>​**   - arrêtez l'​apprentissage avec un **<​Ctrl><​C>​**
-  - inhibez ​le GPU+  - inhibez ​la GPU
   - relancez l'​apprentissage ''/​usr/​bin/​time python CIFAR10.py''​   - relancez l'​apprentissage ''/​usr/​bin/​time python CIFAR10.py''​
   - notez dès le début d'un cycle l'ETA   - notez dès le début d'un cycle l'ETA
Ligne 1713: Ligne 1723:
 </​note>​ </​note>​
  
-Sur la machine **k40** équipée d'une GPU **Tesla K40** ancienne et de deux CPU E5-2609v2, le ratio est de 15. Le plus intéressant vient de la comparaison avec la machine au CBP disposant des processeurs les plus performants : 2 AMD Epyc 7742 avec chacun 64 coeurs. Ces derniers sont 3x moins rapides que la K40 sur cette opération. Ainsi, même de vieux GPU (génération N-5) peuvent encore, dans des opérations de Machine Learning, s'​avérer efficaces, dès lors que les problèmes sont correctement dimensionnés pour eux.+Sur la machine **k40** équipée d'une GPU **Tesla K40** ancienne et de deux CPU E5-2609v2, le ratio est de 15. Le plus intéressant vient de la comparaison avec la machine au CBP disposant des processeurs les plus performants : 2 AMD Epyc 7742 avec chacun 64 coeurs. Ces derniers sont 3x moins rapides que la K40 sur cette opération. Ainsi, même de vieilles ​GPU (génération N-5) peuvent encore, dans des opérations de Machine Learning, s'​avérer efficaces, dès lors que les problèmes sont correctement dimensionnés pour elles.
  
 ==== Intégration et exploitation du code GENESIS ==== ==== Intégration et exploitation du code GENESIS ====
Ligne 1931: Ligne 1941:
   * 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
   * Exécutez le programme "à vide" et identifiez les périphériques   * Exécutez le programme "à vide" et identifiez les périphériques
-  * Exécutez le programme sur le premier ​GPU Nvidia que vous avez repéré+  * Exécutez le programme sur la première ​GPU Nvidia que vous avez repérée
 </​note>​ </​note>​
  
Ligne 1954: Ligne 1964:
 **Exercice #10.3 : exécution sur tous les périphériques pour un PR=1** **Exercice #10.3 : 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 toutes ​(GPU & CPU) avec un nombre d'​itérations de 1 milliard
   * Repérez les éléments de **durée**, **itops** et le **inside**   * Repérez les éléments de **durée**, **itops** et le **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 1976: Ligne 1986:
 **Exercice #10.4 : exécution sur tous les périphériques pour un PR=1024** **Exercice #10.4 : 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 toutes ​(GPU & CPU) avec un nombre d'​itérations de 10 milliards
   * 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 1992: Ligne 2002:
 {{:​formation:​opencluster2_epu.png?​direct&​400|}} {{:​formation:​opencluster2_epu.png?​direct&​400|}}
  
-Ce graphique montre sans ambiguité la puissance "​brute"​ qu'​offre ​un GPU de gamer en comparaison de CPU traditionnel ​(33x dans la meilleure implémentation CPU, celle d'​Intel). Notons également que GPU n'est pas synonyme de puissance brute : la "​petite"​ Quadro K420, bien que "​professionnelle"​ présente des performances 77x inférieures.+Ce graphique montre sans ambiguité la puissance "​brute"​ qu'​offre ​une GPU de gamer en comparaison de CPU traditionnelle ​(33x dans la meilleure implémentation CPU, celle d'​Intel). Notons également que GPU n'est pas synonyme de puissance brute : la "​petite"​ Quadro K420, bien que "​professionnelle"​ présente des performances 77x inférieures.
  
 <note warning> <note warning>
Ligne 2001: Ligne 2011:
   * 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
-  * Quel ratio de performance existe entre le GPU le plus puissant ​et la meilleure implémentation des CPU ?+  * Quel ratio de performance existe entre la GPU la plus puissante ​et la meilleure implémentation des CPU ?
 </​note>​ </​note>​
  
Ligne 2019: Ligne 2029:
 Nous avons présenté dans le cours qu'un mauvais choix de régime de parallélisme pouvait largement influencer la performance. Nous avons présenté dans le cours qu'un mauvais choix de régime de parallélisme pouvait largement influencer la performance.
  
-Par exemple, regardons pour la meilleure implémentation de CPU et pour le GPU le plus puissant, quelle influence a le choix du régime de parallélisme autour du régime de parallélisme optimal.+Par exemple, regardons pour la meilleure implémentation de CPU et pour la GPU la plus puissante, quelle influence a le choix du régime de parallélisme autour du régime de parallélisme optimal.
  
 <note warning> <note warning>
Ligne 2026: Ligne 2036:
   * 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
   * Tracez l'​histogramme avec tous les périphériques OpenCL   * Tracez l'​histogramme avec tous les périphériques OpenCL
-  * Quel ratio de performance existe entre le GPU le plus puissant ​et la meilleure implémentation des CPU ?+  * Quel ratio de performance existe entre la GPU la plus puissante ​et la meilleure implémentation des CPU ?
 </​note>​ </​note>​
  
Ligne 2167: Ligne 2177:
 Nous pouvons constater que la scalabilité est très peu continue, encore moins que pour la scalabilité étudiée des CPU. Nous constatons également que des pseudo-lignes se chevauchent. Le PR optimal était autour de 4x le nombre de //cuda cores// et offrait une performance de **268 Gitops**. Nous pouvons constater que la scalabilité est très peu continue, encore moins que pour la scalabilité étudiée des CPU. Nous constatons également que des pseudo-lignes se chevauchent. Le PR optimal était autour de 4x le nombre de //cuda cores// et offrait une performance de **268 Gitops**.
  
-<note warning>​**Exercice #11.3 : étude de la scalabilité d'un GPU**+<note warning>​**Exercice #11.3 : étude de la scalabilité d'une GPU**
   * Identifiez avec ''​python3 PiXPU.py -h''​ un périphérique GPU   * Identifiez avec ''​python3 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 2344: Ligne 2354:
   * 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
   * Tracez les histogrammes de performances   * Tracez les histogrammes de performances
-  * Quel est le ratio entre le meilleur ​GPU et le meilleur ​en CPU en 32 bits +  * Quel est le ratio entre la meilleure ​GPU et la meilleure ​en CPU en 32 bits 
-  * Quel est le ratio entre le meilleur ​GPU et le meilleur ​en CPU en 64 bits+  * Quel est le ratio entre la meilleure ​GPU et la meilleure ​en CPU en 64 bits
   * Quel est le ratio pour un même périphérique entre 32 et 64 bits ?   * Quel est le ratio pour un même périphérique entre 32 et 64 bits ?
 </​note>​ </​note>​
Ligne 2366: Ligne 2376:
  
 <note warning>​**Exercice #12.3 : lancement de ''​NBody.py''​ en mode ''​-g''​** <note warning>​**Exercice #12.3 : lancement de ''​NBody.py''​ en mode ''​-g''​**
-  * Exécutez le programme pour le meilleur des CPU sur 8192 particules+  * Exécutez le programme pour la meilleure implémentation sur CPU sur 8192 particules
   * Appuyez sur ''​s''​ pour passer des positions aux vitesses   * Appuyez sur ''​s''​ pour passer des positions aux vitesses
   * Utilisez les flèches pour les opérations de rotations   * Utilisez les flèches pour les opérations de rotations
   * Utilisez les <+> ou <-> pour les opérations de zoom ou dézoom   * Utilisez les <+> ou <-> pour les opérations de zoom ou dézoom
   * Sortez avec <Esc> et notez finalement la performance médiane en Squertz   * Sortez avec <Esc> et notez finalement la performance médiane en Squertz
-  * Exécutez le programme sur le GPU le plus puissant ​avec 8192 particules+  * Exécutez le programme sur la GPU la plus puissante ​avec 8192 particules
   * Sortez avec <Esc> et notez la performance médiane en Squertz   * Sortez avec <Esc> et notez la performance médiane en Squertz
-  * Exécutez le programme sur le GPU le plus puissant ​avec 8192 particules+  * Exécutez le programme sur la GPU la plus puissante ​avec 8191 particules
   * Sortez avec <Esc> et notez la performance médiane en Squertz   * Sortez avec <Esc> et notez la performance médiane en Squertz
   * Quel ratio entre Squertz existe entre 8192 et 8191 particules ?   * Quel ratio entre Squertz existe entre 8192 et 8191 particules ?
formation/etsn2022gpu.1658394301.txt.gz · Dernière modification: 2022/07/21 11:05 par equemene