Formation Programmation C/C++ Multicore : Optimisez vos applications

01.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++

02.Threads et API Posix Threads (Pthreads) - Bases

03.Synchronisation avancée avec Pthreads

04.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)

05.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`)

06.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

07.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

08.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

09.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

10.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

11.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)

12.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