PREMIERS PAS
1.
Si l'application existe, la profiler globalement
#23
(WIP)
❱
1.1.
Introduction (
#14
) (WIP)
❱
1.1.1.
Audience
1.1.2.
Prérequis (WIP)
1.1.3.
Objectifs
1.2.
Contexte et objectifs (
#7
)
❱
1.2.1.
Maturité de l'application
1.2.2.
Matériel cible
1.2.3.
Compromis latence/débit
1.3.
Optimiser la reproductibilité (
#8
)
❱
1.3.1.
La question du réalisme
1.3.2.
Reproductibilité au niveau système
1.3.3.
Reproductibilité du
benchmark
1.4.
Identifier les ressources matérielles limitantes (
#9
) (WIP)
❱
1.4.1.
Activité système à surveiller
1.4.2.
Critères de choix d'un moniteur système
1.4.3.
Logiciels pour Linux (WIP)
1.5.
Pour aller plus loin (WIP)
❱
1.5.1.
Ressources extérieures (WIP)
1.5.2.
Tutoriels (WIP)
1.6.
Retours d'expériences
1.7.
Bibliographie
2.
Choisir une technologie adaptée au problème traité
#22
❱
2.1.
Introduction
2.2.
Pour aller plus loin
❱
2.2.1.
Ressources extérieures
2.2.2.
Tutoriels
2.3.
Retours d'expériences
2.4.
Bibliographie
3.
Commencer par la technologie la moins invasive
#20
❱
3.1.
Introduction
3.2.
Pour aller plus loin
❱
3.2.1.
Ressources extérieures
3.2.2.
Tutoriels
3.3.
Retours d'expériences
3.4.
Bibliographie
4.
Rendre la précision configurable, et l'ajuster au besoin
#21
❱
4.1.
Introduction
❱
4.1.1.
Conversion décimal-binaire et binaire-décimal
4.1.2.
Erreur de calcul
❱
4.1.2.1.
Différence de carrés
4.1.2.2.
Solutions de l'équation du second degré
4.1.2.3.
Calcul de variance
4.1.2.4.
Somme
4.1.2.5.
Évaluation de polynômes
4.1.2.6.
Aire d'un triangle
4.1.2.7.
Minimisation d'une fonction
4.1.2.8.
La double précision comme assurance
4.1.2.9.
Quelques cas particuliers notables
❱
4.1.2.9.1.
Arithmétique et analyse complexe
4.1.2.9.2.
Arithmétique par intervalles
4.1.2.9.3.
Bonne nouvelle sur le front de la précision
4.1.3.
Sécurité numérique et évaluation de la précision d'un calcul
❱
4.1.3.1.
Arithmétique stochastique
4.1.3.2.
Impact de la parallélisation sur la précision
4.1.4.
Reproductibilité des résultats
4.2.
Pour aller plus loin
❱
4.2.1.
Ressources extérieures
4.2.2.
Tutoriels
4.3.
Retours d'expériences
4.4.
Bibliographie
5.
Structurer les données en tableaux
#17
(WIP)
❱
5.1.
Introduction
5.2.
Optimisation du format de données
❱
5.2.1.
Contiguïté des données
5.2.2.
Préchargement des données
5.2.3.
Localité des données
5.2.4.
Caches CPU
5.2.5.
Tableau, vecteur ou liste ?
5.3.
Implication en terme de développement (WIP)
❱
5.3.1.
Format de données plat ?
5.3.2.
Exemples de formats de données plats (WIP)
5.4.
Pour aller plus loin
❱
5.4.1.
Ressources extérieures
5.4.2.
Tutoriels
5.5.
Retours d'expériences
5.6.
Bibliographie
6.
Privilégier une algorithmie éhontement parallèle
#18
(WIP)
❱
6.1.
Introduction (WIP)
❱
6.1.1.
Algorithme et complexité (WIP)
6.1.2.
Pourquoi le changement d'échelle est-il un problème ?
6.1.3.
Comment éviter le problème de l'échelle ? (WIP)
6.2.
Intéraction de N particules
❱
6.2.1.
Algorithme force brute
6.2.2.
Essayons de limiter le problème
6.2.3.
Algorithme à base de tri (octree ou quadtree)
❱
6.2.3.1.
Que sont les octree et les quadtree ?
6.2.3.2.
Intéraction avec un octree ou un quadtree
6.2.3.3.
Avec quelle précision
6.2.4.
Parallélisation
6.2.5.
Sur quelles architectures
6.3.
Tri de valeurs
❱
6.3.1.1.
Le tri à bulles
6.3.1.2.
Le tri rapide
6.4.
Mutiplication de matrices
❱
6.4.1.
Algorithme classique
6.4.2.
Multiplication de matrices rapide
❱
6.4.2.1.
Multiplication rapide de matrice 2x2
❱
6.4.2.1.1.
Algorithme de Strassen (fast 2x2)
6.4.2.1.2.
Algorithme de Winograd (fast 2x2)
6.4.2.2.
Multiplication rapide de matrice 3x3
❱
6.4.2.2.1.
Algorithme de Laderman (fast 3x3)
6.4.2.2.2.
Un algorithme encore plus fort
6.4.2.3.
Algorithme fast 5x5
6.5.
Calcul de déterminant
❱
6.5.1.
Algorithme classique
6.5.2.
Déterminant par décomposition de Gauss
6.6.
Calcul de l'inverse d'une matrice
❱
6.6.1.
Algorithme classique
6.6.2.
Algorithme de Gauss
6.7.
Pour aller plus loin (WIP)
❱
6.7.1.
Ressources extérieures (WIP)
6.7.2.
Tutoriels (WIP)
6.8.
Retours d'expériences (WIP)
6.9.
Bibliographie (WIP)
7.
Exprimer les noyaux de calcul dans un style fonctionnel
#19
POUR ALLER PLUS LOIN
8.
Implémentation et performance (WIP)
9.
Vous avez dit évaluation de performances ? (WIP)
❱
9.1.
Introduction (WIP)
9.2.
Pour aller plus loin
❱
9.2.1.
Ressources extérieures
9.2.2.
Tutoriels
9.3.
Retours d'expériences (WIP)
9.4.
Bibliographie
10.
Niveaux de Parallélisme et niveaux de stockage (WIP)
❱
10.1.
Dans un CPU (WIP)
❱
10.1.1.
Unité Arithmérique et Logique
❱
10.1.1.1.
Unités de calcul
10.1.2.
Registres mémoire
10.1.3.
Caches mémoire (WIP)
❱
10.1.3.1.
Cache L1 des données
10.1.3.2.
Cache L1 des instructions (WIP)
10.1.3.3.
Cache L2
10.1.3.4.
Cache L3
10.1.4.
Multi-threading matériel (WIP)
10.1.5.
Coeur de calcul
10.2.
Random Access Memory (RAM)
10.3.
Noeud Non Uniform Memory Access (NUMA)
10.4.
Dans un GPU (WIP)
❱
10.4.1.
Streaming multiprocessor
10.4.2.
Mémoire partagée
10.4.3.
Mémoire Globale
10.5.
Serveur lame
10.6.
Stockage persistant (WIP)
❱
10.6.1.
Disques SSD
10.6.2.
Disques Durs
10.6.3.
Stockage sur bande (WIP)
10.7.
Rack
10.8.
Centre de calcul
10.9.
Grille de calcul (WIP)
10.10.
Optimisation et prédicteur de branchements
11.
Parties à recycler du rapport de prospective
❱
11.1.
Introduction
11.2.
Pourquoi optimiser les programmes ?
❱
11.2.1.
Qu'apporte l'optimisation des programmes ?
11.2.2.
Méthodes d'optimisation
❱
11.2.2.1.
Préparer l'optimisation
11.2.2.2.
Optimisation du format de données
❱
11.2.2.2.1.
Contiguïté des données
11.2.2.2.2.
Préchargement des données
11.2.2.2.3.
Localité des données
11.2.2.2.4.
Caches CPU
11.2.2.2.5.
Tableau, vecteur ou liste ?
11.2.2.3.
Optimisation du calcul
❱
11.2.2.3.1.
Bibliothèques bas niveau
11.2.2.3.2.
Bibliothèques haut niveau
11.2.2.3.3.
Changer d'algorithme
11.2.2.3.4.
Effectuer moins de calculs
11.2.2.3.5.
Réduire l'empreinte mémoire
11.2.2.3.6.
Supprimer certain branchements
11.2.3.
Impact du cycle de développement sur les optimisations
11.3.
Pourquoi et comment vectoriser ?
❱
11.3.1.
Principe de la vectorisation
11.3.2.
Pourquoi vectoriser ?
11.3.3.
Ce calcul est-il vectorisable ?
❱
11.3.3.1.
Propriétés du format de données
❱
11.3.3.1.1.
Données contiguës
11.3.3.1.2.
Données alignées
11.3.3.2.
Indépendances des éléments
11.3.4.
Comment vectoriser ?
❱
11.3.4.1.
Vectoriser avec le compilateur
11.3.4.2.
Utiliser des fonctions intrinsèques
11.3.4.3.
Les bibliothèques optimisées
11.3.4.4.
Les bibliothèques d'auto-vectorisation
11.3.4.5.
Les générateurs de code
11.3.5.
Ce code a-t-il été vectorisé par le compilateur ?
11.3.6.
Retours d'expériences
❱
11.3.6.1.
Vectorisation de la simulation CORSIKA
❱
11.3.6.1.1.
Introduction à la simulation CORSIKA
11.3.6.1.2.
Retour d'expérience
11.3.6.2.
Vectorisation de l'analyse de CTA
❱
11.3.6.2.1.
L'expérience CTA
11.3.6.2.2.
Retour d'expérience
11.3.6.3.
Vectorisation dans \smilei
❱
11.3.6.3.1.
Le code \smilei
11.3.6.3.2.
Retour d'expérience
11.3.7.
Recommandations pour le long terme
❱
11.3.7.1.
Structure/Stockage de données
11.3.7.2.
Bonnes pratiques
11.3.7.3.
Vectoriser un programme existant
11.3.7.4.
Vectoriser un nouveau programme
11.4.
Parallélisation
❱
11.4.1.
Introduction
11.4.2.
Considérations théoriques
❱
11.4.2.1.
Granularité des tâches
11.4.2.2.
Passage à l'échelle
❱
11.4.2.2.1.
Introduction
11.4.2.2.2.
Loi d'Amdahl
11.4.2.2.3.
Loi de Gustafson
11.4.2.2.4.
Applications réelles
11.4.2.3.
Parallélisation sur la Grille
11.4.3.
Formes de parallélisation
❱
11.4.3.1.
Introduction
11.4.3.2.
Parallélisation multi-cœur
❱
11.4.3.2.1.
Threads, cœurs et processeurs
11.4.3.2.2.
Mémoire partagée et cohérence de cache
11.4.3.2.3.
Abstractions d'exécution parallèle
11.4.3.2.4.
Synchronisation
11.4.3.2.5.
Abstractions d'ordre supérieur
11.4.3.2.6.
Paradigmes pour le parallélisme
11.4.3.3.
Parallélisme multi-nœud
❱
11.4.3.3.1.
La fin des certitudes
11.4.3.3.2.
Réseau
11.4.3.3.3.
Du paquet au message
11.4.3.3.4.
Limite des messages
11.4.3.3.5.
Approches haut niveau
11.4.3.3.6.
Tolérance aux pannes
11.4.4.
Les aléas du parallélisme
❱
11.4.4.1.
Passage à l'échelle
11.4.4.2.
Équilibrage de charge
11.4.4.3.
Algorithmie
11.4.4.4.
Débogage
11.4.4.5.
Profilage
11.4.5.
Retours d'expériences
❱
11.4.5.1.
Introduction
11.4.5.2.
Multi-threading en physique des particules
11.4.5.3.
Calcul distribué dans LSST
11.4.6.
Conclusion
11.5.
Quels langages de programmation~?
❱
11.5.1.
Introduction
11.5.2.
C
11.5.3.
C++
11.5.4.
Fortran
11.5.5.
Ada
11.5.6.
Rust
11.5.7.
Go
11.5.8.
Python
11.5.9.
Julia
11.5.10.
Conclusions
11.6.
Des FPGAs pour le calcul~?
❱
11.6.1.
FPGA~: généralités
❱
11.6.1.1.
Qu'est-ce qu'un FPGA ?
11.6.1.2.
Comment programmer un FPGA ?
11.6.1.3.
Programmer des calculs sur le FPGA
❱
11.6.1.3.1.
Parallélisme sur GPU et sur FPGA
11.6.2.
Calcul sur FPGA avec OpenCL
❱
11.6.2.1.
Le matériel
11.6.2.2.
La programmation
11.6.3.
Évolution des accélérateurs avec FPGA Altera/Intel
❱
11.6.3.1.
Solutions Intel avec OpenVINO pour l'apprentissage automatique
11.6.4.
Accélération avec FPGA Xilinx sur la plate-forme ACP du Laboratoire Leprince-Ringuet
11.7.
Les GPUs... pour quoi faire ?
❱
11.7.1.
Introduction
❱
11.7.1.1.
Structure d'un GPU
11.7.1.2.
Fonctionnement d'un GPU
11.7.2.
Omniprésence des GPUs
11.7.3.
Utilisation des GPUs
11.7.4.
Programmation
❱
11.7.4.1.
Langages de programmation bas niveau
11.7.4.2.
Langages de programmation haut niveau
11.7.5.
Retour sur expériences
❱
11.7.5.1.
Projet Sympatick_G
11.7.5.2.
Projet CMS-MEM
❱
11.7.5.2.1.
Une méthode d'analyse pour CMS
11.7.5.2.2.
Contraintes et défis technologiques
11.7.5.2.3.
Production sur la plate-forme GPUs du CC-IN2P3
11.7.5.2.4.
Remerciements
11.7.5.3.
Projet Electron_Capture
❱
11.7.5.3.1.
Un calcul pour l'astrophysique nucléaire théorique
11.7.5.3.2.
Perspectives
11.7.5.3.3.
Remerciements
11.7.6.
Recommandations
11.8.
La problématique de la précision
❱
11.8.1.
Introduction
❱
11.8.1.1.
Conversion décimal-binaire et binaire-décimal
11.8.2.
Erreur de calcul
❱
11.8.2.1.
Différence de carrés
11.8.2.2.
Solutions de l'équation du second degré
11.8.2.3.
Calcul de variance
11.8.2.4.
Somme
11.8.2.5.
Évaluation de polynômes
11.8.2.6.
Aire d'un triangle
11.8.2.7.
Minimisation d'une fonction
11.8.2.8.
La double précision comme assurance
11.8.2.9.
Quelques cas particuliers notables
❱
11.8.2.9.1.
Arithmétique et analyse complexe
11.8.2.9.2.
Arithmétique par intervalles
11.8.2.9.3.
Bonne nouvelle sur le front de la précision
11.8.3.
Sécurité numérique et évaluation de la précision d'un calcul
❱
11.8.3.1.
Arithmétique stochastique
11.8.3.2.
Impact de la parallélisation sur la précision
11.8.4.
Reproductibilité des résultats
11.9.
Recommandation de production de logiciels open-source
❱
11.9.1.
Introduction
11.9.2.
Modularité
11.9.3.
Réutilisabilité
11.9.4.
Développement
❱
11.9.4.1.
Convention de nommage
11.9.4.2.
Écrire des fonctions courtes
11.9.4.3.
Outils de développement
11.9.4.4.
Cycles courts
11.9.4.5.
Tests unitaires
11.9.4.6.
Tests de qualité d'exécution/fuites mémoire
11.9.5.
Chaîne de compilation
❱
11.9.5.1.
Choix du compilateur
11.9.6.
Documentation
11.9.7.
Gestion des versions et sauvegarde des projets
❱
11.9.7.1.
Utilisation de ces outils
11.10.
Conclusion
❱
11.10.1.
Enseignements à propos de la quête de performance
❱
11.10.1.1.
Optimisation
11.10.1.2.
Vectorisation
11.10.1.3.
Parallélisation
11.10.1.4.
Langages de programmation
11.10.1.5.
Calcul sur FPGA
11.10.1.6.
Calcul sur GPU
11.10.1.7.
Problématique de la précision
11.10.1.8.
Recommandations de production de logiciel open source
11.10.2.
Thèmes techniques prioritaires
❱
11.10.2.1.
Profilage du calcul et des entrées/sorties en contexte parallèle
11.10.2.2.
Structures de données performantes
11.10.2.3.
Modes de programmation PPP
11.10.2.4.
Calcul sur FPGA
11.10.2.5.
Calcul multi-précision
11.10.2.6.
Reproductibilité numérique en contexte parallèle et hétérogène
11.10.2.7.
Apprentissage automatique
11.10.3.
Recommandations stratégiques
❱
11.10.3.1.
Recruter des ingénieurs pour le calcul
11.10.3.2.
Former massivement
11.10.3.3.
Avoir le matériel approprié pour une veille active
11.10.3.4.
Développer une recherche appliquée interne
11.10.3.5.
Constituer une force de frappe trans-laboratoires "IN2P3 Optimisation"
ANNEXES
12.
Conférences
❱
12.1.
GTC
: GPU Technical Conference
❱
12.1.1.
GTC 2021 NVidia
❱
12.1.1.1.
HPC et infrastructures
12.1.1.2.
Sécurité
12.1.1.3.
Calcul et simulation
12.1.1.4.
Compilateur, langages et developpement
12.1.1.5.
Compression
12.1.1.6.
Machine Learning / Deep Learning
12.1.1.7.
Rendu 3d, production et travail collaboratif
12.1.1.8.
Trucs que je ne sais pas dans quelle catégorie les mettre
12.2.
GTC 2022
❱
12.2.1.
Keynotes
12.2.2.
Hardware
12.2.3.
Langages de programmation et développement
12.2.4.
HPC
12.2.5.
GPU
12.2.6.
Algo
12.2.7.
Machine Learning
12.2.8.
Omniverse
12.2.9.
Computing center
12.2.10.
3D
12.2.11.
Pot pourri
12.3.
GTC 2023
❱
12.3.1.
Keynotes
12.3.2.
Hardware
12.3.3.
HPC
12.3.4.
Developpement HPC
12.3.5.
AI
12.3.6.
Simulation
12.4.
GTC 2024
❱
12.4.1.
Keynotes
12.4.2.
Hardware
12.4.3.
HPC
12.4.4.
Developpement HPC
12.4.5.
AI
12.4.6.
Simulation
12.4.7.
Calcul Quantique
12.4.8.
Cybersécurité
12.4.9.
Rendu
13.
A propos du projet IN2P3 Reprises
❱
13.1.
Participants
13.2.
Publications
13.3.
Intention
Bibliography
Navy
10.1.3.3 : Cache L2
Le
CPU
accède à une donnée en $5$ à $7$ cycles et a une taille typique de $256$ ko. Plus grand niveaux de stockage dans un coeur de calcul (voir section
10.1.5
)
