Programme de la formation
Programmation C/C++ Multicore : Optimisez vos applications

• Introduction aux architectures multicœurs et programmation parallèle

  - Comprendre les architectures CPU modernes (coeurs, caches, hiérarchies)
  - Concepts fondamentaux de la programmation parallèle (concurrence, parallélisme)
  - Avantages et défis de la programmation multicœurs
  - Présentation des modèles de programmation parallèle en C/C++

• Threads et API Posix Threads (Pthreads) - Bases
• Synchronisation avancée avec Pthreads
• Problèmes classiques du parallélisme et détection

  - Deadlock, livelock, famine : identification et prévention
  - Conditions de course : comprendre et éviter
  - Atomicité et opérations atomiques (`std::atomic` en C++11)
  - Outils de détection de problèmes de concurrence Valgrind (Helgrind, DRD)

• Introduction à OpenMP pour la programmation parallèle

  - Philosophie et directives principales d'OpenMP
  - Parallélisation de boucles (`#pragma omp for`)
  - Variables partagées et privées (`shared`, `private`)
  - Réduction (`reduction`)

• OpenMP: Gestion des sections et des tâches

  - Parallélisation de sections indépendantes (`#pragma omp sections`)
  - Exécution de tâches asynchrones (`#pragma omp task`)
  - Synchronisation avec OpenMP (`#pragma omp critical`, `atomic`, `barrier`)
  - Clauses avancées et optimisation

• Introduction à C++11/14/17 - Le modèle mémoire

  - Le modèle mémoire C++ et ses implications pour le parallélisme
  - `std::thread` : création et gestion de threads en C++
  - `std::mutex` : synchronisation en C++ moderne
  - `std::lock_guard`, `std::unique_lock` : gestion sécurisée des mutex

• C++11/14/17 - Synchronisation avancée et futures

  - `std::condition_variable` pour la signalisation
  - `std::atomic` : opérations atomiques et ordres de mémoire
  - `std::future`, `std::promise` : gestion des résultats asynchrones
  - `std::async` : exécution asynchrone simple

• Les algorithmes parallèles de la STL (C++17)

  - Introduction aux algorithmes parallèles de la STL (chapitre `<execution>`)
  - Appliquer des politiques d'exécution (`std::execution::par`, `par_unseq`)
  - Exemples pratiques : `std::sort`, `std::for_each`, `std::transform` en parallèle
  - Avantages et limitations des algorithmes parallèles de la STL

• Optimisation des performances et scalabilité

  - Granularité des tâches et surcharge du parallélisme
  - Éviter les faux partages (false sharing) et maximiser la localité cache
  - Analyse de performance et profilage (Intel VTune, Valgrind Callgrind)
  - Loi d'Amdahl et loi de Gustafson : limites du parallélisme

• Structures de données concurrentes et sans verrou (lock-free)

  - Introduction aux structures de données thread-safe
  - Les pièges des collections partagées simples
  - Présentation de queues, stacks et hashmaps concurrentes
  - Introduction aux algorithmes lock-free (ABA problem CAS)

• Cas d'usage et déploiement pratique

  - Exemples concrets d'applications multicœurs (calcul scientifique, jeux, serveurs)
  - Stratégies de parallélisation pour différents types de problèmes
  - Débogage de code parallèle : techniques et outils spécifiques
  - Bonnes pratiques pour l'intégration et la maintenance de code parallèle