Formation OpenMP

PROGRAMME DE NOTRE FORMATION OpenMP

Introduction au parallélisme et à OpenMP

• Les processeurs modernes comportent plusieurs cœurs : pour profiter pleinement du matériel, il faut exécuter des calculs en parallèle.
• Le parallélisme améliore les performances, surtout sur les traitements lourds (calculs scientifiques, IA, simulations…).
• Deux grands types de parallélisme :
  • Mémoire partagée : tous les threads partagent la même RAM (OpenMP)
  • Mémoire distribuée : chaque processus a sa mémoire (MPI)
• OpenMP (Open Multi-Processing) est une API pour C, C++ et Fortran.
• Permet de paralléliser sans gérer manuellement les threads (vs pthread ou std::thread).
• Basée sur des directives de compilation (#pragma omp), elle est simple à intégrer dans un code existant.
• Compatible avec GCC, Clang, Intel, MSVC…
• Compiler : gcc ou clang avec l’option -fopenmp

Premiers pas avec les threads

• Directive de base 
• Utilisation de “omp_get_thread_num()” pour connaître l’identité du thread.
• “omp_get_num_threads()” : nombre de threads utilisés
• “omp_set_num_threads(n)” : fixer le nombre avant la région parallèle
• Objectif : afficher un message depuis chaque thread
• Observation : threads ne s’exécutent pas dans l’ordre

Paralléliser les boucles

• Permet de répartir les itérations d’une boucle entre threads :
• Par défaut, certaines variables sont partagées (globales), d’autres privées (locales à chaque thread).
• Appliquer une transformation à un grand tableau en parallèle
• Mesurer le gain de temps avec “omp_get_wtime()”

Réduction et agrégation des résultats

• Si plusieurs threads modifient une variable partagée (ex : somme), ça cause une condition de course.
• Directive OpenMP qui permet d’agréger les résultats sans collision
• Comparer version séquentielle, version parallèle naïve (bug), version avec reduction
• Analyser les erreurs liées aux variables partagées

Contrôle des tâches et synchronisation

• #pragma omp barrier : attend que tous les threads arrivent
• #pragma omp critical : section protégée, un seul thread à la fois
• #pragma omp atomic : opération atomique plus rapide mais limitée
• Simuler un traitement en 3 étapes (lecture, calcul, sauvegarde) avec sections

Gestion des performances et planification

• Contrôle de la distribution du travail :
  • Static : parts fixes
  • Dynamic : planification à la volée
  • Guided : dynamique mais décroissante
• Tester différentes stratégies de planification sur une boucle où les temps de traitement varient

Paralléliser un projet réel

• Version séquentielle
• Analyse des dépendances
• Parallélisation progressive avec OpenMP
• Optimisation : éviter les accès mémoire coûteux
• Paralléliser un programme au choix (filtrage image, tri, statistiques…)
  • Identifier les boucles critiques
  • Ajouter les directives
  • Mesurer les performances
  • Éviter les conditions de course

Bonnes pratiques et perspectives

• Variables mal déclarées (shared vs private)
• Accès concurrent sans critical ou reduction
• Trop de threads = surcharge CPU
• Toujours mesurer les performances
• Paralléliser progressivement
• Favoriser les traitements indépendants
• Comparaison avec MPI, CUDA, OpenACC
• OpenMP + SIMD
• Profilage avec gprof, perf, Intel VTune