Cours 5 Modle mmoire partage

1
Cours 5Modèle à mémoire partagée

• Pierre Delisle
• Université du Québec à Chicoutimi
• Département dinformatique et de mathématique

2
Plan de la présentation

• Introduction
• Modèle à mémoire partagée
• Les threads
• Modèle Fork/Join
• Caractéristiques du modèle
• Outils de développement
• OpenMP
• Description dun programme OpenMP en C

3
Vue densemble simplifiée du calcul parallèle des
années 2000
4
Introduction

• Le succès de lapproche par passage de messages a
  contribué significativement au développement du
  parallélisme depuis 15 ans
• Lintérêt pour le calcul parallèle sest
  généralisé
• Bassin dutilisateurs plus vaste
• Chercheurs et industriels dans différents
  domaines, pas tous des spécialistes en
  informatique/parallélisme !
• Besoin denvironnements plus faciles à utiliser
• Lémergence des SMP a favorisé développement
  pratique du modèle à mémoire partagée

5
Modèle à mémoire partagée

• Plusieurs processus sexécutent en parallèle
• Processus attribués à des processeurs distincts
• La mémoire est partagée (physiquement ou
  virtuellement)
• Les communications entre processeurs se font par
  lectures et écritures dans la mémoire partagée

6
Modèle à mémoire partagée

• Particulièrement adapté aux architectures à
  mémoire partagée (de type SIMD et MIMD)
• Multiprocesseurs
• Centralisés -gt SMP (IBM SP3/SP4)
• Distribués gt CC-NUMA (SGI Origin 3800)
• 2 principales représentations
• Threads
• Fork/Join

7
Modèle de threads

• Programme ensemble de processus légers
  (threads) qui coopèrent afin de réaliser un
  objectif commun
• Thread entité logique, fonction, correspondant
  à une partie de programme
• pouvant sexécuter indépendamment des autres
  parties
• pouvant sexécuter de façon concurrente
• possédant des données locales et globales
• Un programme écrit sous forme de threads peut
  être exécuté séquentiellement
• Pseudo-parallélisme
• Partage du temps CPU entre les threads durant
  lexécution
• Changements de contexte (context switchs)

8
Modèle de threads

• Ce même programme peut aussi être exécuté de
  façon réellement parallèle
• Répartition des threads sur les processeurs
• Un ou plusieurs threads par processeur
• Communication par les données globales stockées
  dans la mémoire qui est partagée
• Fonctionnalités pour
• La gestion des threads (création, destruction,
  etc.)
• Lordonnancement et létat des threads (actif,
  exécutable, en exécution, en veille, etc.)
• La synchronisation (sémaphores, barrières, etc.)

9
Modèle fork/join
Thread maître

• Thread maître
• Exécution du code séquentiel
• Débute et termine lexécution
• Fork création de threads esclaves
• Threads esclaves
• Exécutent la portion parallèle
• Join destruction des esclaves et retour du
  contrôle au maître
• Le nombre de threads peut varier durant
  lexécution
• Permet la parallélisation incrémentale

Fork
Threads esclaves
Join
Fork
Join
10
Caractéristiques du modèle

• Facilité de programmation - Transparence
• Ressemble beaucoup au modèle séquentiel
• Communications indirectes généralement plus
  faciles à gérer que le passage de messages
• La gestion des synchronisations doit se faire
  autrement que par des messages
• Régions critiques
• Barrières
• Sémaphores

11
Caractéristiques du modèle

• Problème de localité des données
• Structurer le code pour tirer profit des caches
  (si possible)
• Exemple inversion ligne/colonne dune matrice
• Efficacité non garantie
• La transparence facilite la tâche du programmeur,
  mais loptimisation de la performance est plus
  difficile
• Lorganisation matérielle de la mémoire peut
  avoir un impact important pour le même code sur 2
  machines

12
Développement dapplications basées sur le modèle
à mémoire partagée

• Principaux modèles de programmation
• Modèles de threads
• Pthreads -gt largement utilisé dans les
  bibliothèques des systèmes de type UNIX
• Java Threads -gt extension du langage Java qui
  encapsule une classe Thread
• Programmation à mémoire partagée structurée
  (Structured Shared-Memory Programming)
• OpenMP

13
OpenMP

• Ensemble doutils permettant détendre des
  langages séquentiels existants
• Directives de compilation
• Appels de routines de bibliothèque
• Variables denvironnement
• API permettant dexprimer un modèle de
  parallélisme à mémoire partagée dans des
  programmes
• C - C
• 1.0 -gt Oct. 1998
• 2.0 -gt Mars 2002
• Fortran
• 1.0 -gt Oct. 1997
• 2.0 -gt Nov. 2000)
• C C - Fortran
• 2.5 -gt Mai 2005

14
OpenMP

• Permet lécriture de programmes portables sur la
  plupart des multiprocesseurs
• Le programmeur spécifie aux compilateur et au
  système les actions à faire pour exécuter un
  programme en parallèle
• Responsable de lexactitude du programme (gestion
  des race conditions, des synchronisations, etc.)
• OpenMP ! générateur de code parallèle
• Permet décrire un seul programme pouvant être
  exécuté de façon parallèle ou séquentielle
• Parallélisme de type SPMD (Single Program
  Multiple Data)

15
Développement de programmes en C avec OpenMP

• Parallélisme de type Fork-Join
• Parties de code séquentielles
• Parties de code parallèles (Régions parallèles)
• Vision de la mémoire en 2 niveaux
• Partagée -gt Variables accessibles par tous les
  threads (shared)
• Privée -gt Variables locales aux threads (private,
  threadprivate)
• Inclusion de la bibliothèque OpenMP
• include ltopenmp.hgt
• Format dune directive de compilation
• pragma omp nom-directive clause , clause
• clause composante additionnelle optionnelle

16
Ajustement de quelques paramètres importants

• Modifier le nombre de threads qui seront actifs
  dans les régions parallèles du programme
• Par la modification de la variable
  denvironnement
• setenv OMP_NUM_THREADS
• Par un appel à une routine à lintérieur du
  programme
• void omp_set_num_threads(int i)
• Peut être modifié plusieurs fois durant une
  exécution
• Obtenir le nombre de processeurs disponibles
• int omp_get_num_procs (void)
• Le système détermine ce nombre, peut être
  inférieur au nombre réel de processeurs
• Habituellement nb threads nb procs

17
Boucles pour parallèles

• Exécution des itérations de la boucle sur
  plusieurs processeurs
• Itérations indépendantes -gt Maximum de
  performance
• Itérations dépendantes -gt Synchronisations
  nécessaires
• pragma omp parallel for
• for (i 0 i lt n i)
• Ai 1
• Le thread maître crée des esclaves et toute
  léquipe coopère à exécuter les itérations

18
Boucles pour parallèles

• Si on a la double boucle suivante
• for (i 0 i lt x i)
• for (j 0 j lt n j)
• aij min(aij, aik tmpj)
• Comment paralléliser à laide de la directive
  ltomp parallel forgt ?
• Les variables sont partagées par défaut. Que se
  passe-t-il avec la variable j ?
• Solution privatiser

19
Privatisation de variables

• Utilisation de la clause private
• private (ltliste-de-variablesgt)
• Spécifie au compilateur de créer une copie privée
  de la variable pour chaque thread
• pragma omp parallel for private (j)
• for (i 0 i lt x i)
• for (j 0 j lt n j)
• aij min(aij, aik tmpj)
• Valeur de j à lentrée et à la sortie -gt
  indéterminée
• clause firstprivate -gt copie la valeur
  initiale de j pour tous
• clause lastprivate -gt copie la valeur de la
  dernière itération séquentielle de j à la
  variable du maître

20
Le problème de Race condition

• Ou Condition de concurrence , situation de
  compétition
• int i, n double x, area 0.0
• pragma omp parallel for private (x)
• for (i 0 i lt n i)
• x (i 0.5) / n
• area 4.0 / (1.0 xx)
• Conséquence comportement indéterminé
• Solution sémaphore

Race condition area est partagé et plusieurs
threads tentent dy accéder en parallèle
21
Sémaphore

• Mécanisme primitif de synchronisation, souvent
  utilisé par les systèmes dexploitation
• Variable sem , valeur initialisée au nombre de
  ressources disponibles
• Acquisition (sem)
• tant que sem.valeur lt 0 //attente
• sem.valeur--
• Libération (sem)
• sem.valeur
• Opérations atomiques (indivisibles)

22
Sémaphore

• Sémaphore binaire un thread à la fois
• Exclusion mutuelle (mutex)
• sem.valeur 1
• tant que (non terminé)
• Acquisition(sem)
• //Code devant être effectué en séquentiel
• Libération(sem)
• //Code pouvant être effectué en parallèle
• Solution OpenMP section critique

23
Section critique

• Partie de code ne pouvant être exécutée que par
  un thread à la fois
• pragma omp critical
• int i, n double x, area 0.0
• pragma omp parallel for private (x)
• for (i 0 i lt n i)
• x (i 0.5) / n
• pragma omp critical
• area 4.0 / (1.0 xx)
• Conséquence Exécution correcte, mais efficacité
  parallèle limitée
• Lopération sur area peut être mieux parallélisée
  en effectuant une réduction

24
Réduction

• Une clause OpenMP permet deffectuer lopération
  de réduction (vue la semaine passée)
• reduction(ltopgtltvariablegt)
• op opérateur de réduction (, , min, max, ET,
  OU, etc)
• variable variable partagée qui est lobjet de
  la réduction
• int i, n double x, area 0.0
• pragma omp parallel for private (x)
  reduction(area)
• for (i 0 i lt n i)
• x (i 0.5) / n
• area 4.0 / (1.0 xx)
• Le système soccupe du reste
• Coût de la réduction lt coût de la section critique

25
Amélioration des performances

• Inversion de boucles
• Exécution conditionnelle dune boucle
• Ordonnancement des itérations dune boucle

26
Inversion de boucles

• for (i 0 i lt m i)
• for (j 0 j lt n j)
• aij 2 ai-1j
• Boucle i non parallélisable
• Boucle j parallélisable, mais trop de
  fork/join
• Solution inversion des boucles
• pragma omp parallel for private (i)
• for (j 0 j lt n j)
• for (i 0 i lt m i)
• aij 2 ai-1j

27
Exécution conditionnelle dune boucle

• Nombre ditérations dune boucle trop petit
• Temps fork/join gt Temps sauvé en parallélisant
• On peut dire au compilateur de paralléliser
  seulement si une certaine condition est remplie
• pragma omp parallel for private(x) if(n gt 5000)
• for (i 0 i lt n i)
• .
• n lt 5000 -gt exécution séquentielle

28
Ordonnancement des itérations

• Par défaut, les n itérations dune boucle
  parallel for sont distribuées statiquement, n/p
  itérations par thread
• Si le temps dexécution dune itération par
  rapport à une autre peut être très grand, une
  telle distribution peut limiter la performance
• La clause schedule -gt ordonnancement
• static (défaut) -gt toutes les itérations
  attribuées au début
• dynamic -gt itérations attribuées durant
  lexécution
• Compromis
• coût (overhead) vs. équilibre de la charge

29
Ordonnancement des itérations

• Format de la clause schedule
• schedule (lttypegt, ltchunkgt)
• type type dordonnancement
• chunk (optionnel) taille du groupe ditérations
• Exemples
• schedule(static) allocation statique (n/p
  itér./thread)
• schedule(static, c) allocation cyclique (c
  itér./thread)
• schedule(dynamic) allocation dynamique (1
  itér./thread)
• schedule(dynamic, c) alloc. dynamique (c
  itér./thread)
• schedule(guided) scheduling automatique par
  heuristique
• pragma omp parallel for schedule(static, 5)
• for (i 0 i lt n i)

30
Parallélisation à lextérieur des boucles

• Réplication du code pour tous les threads
• pragma omp parallel
• Création dun groupe de threads numérotés de 0 à
  p-1
• Certaines clauses peuvent être utilisées
• if, private, firstprivate, reduction, etc
• Un thread peut connaître son numéro id
• int omp_get_thread_num(void)
• À la fin de la région parallèle, les threads sont
  détruits, à lexception du maître qui reprend
  lexécution séquentielle

31
Parallélisation dune boucle à lintérieur dune
région parallèle

• pragma omp parallel
• for (i 0 i lt n i)
• On peut répartir les itérations entre les threads
• pragma omp for
• pragma omp parallel
• pragma omp for
• for (i 0 i lt n i)

La boucle for sera exécutée n fois pour
chaque thread, donc np fois
La boucle for sera répartie entre les
threads, donc exécutée n fois
32
Quelques directives additionnelles

• Sérialisation dune partie de code à lintérieur
  dune région parallèle
• pragma omp single (effectué par le 1er thread
  arrivé)
• pragma omp master (effectué par le maître
  seulement)
• Empêcher la barrière de synchronisation par
  défaut lors dun omp for
• pragma omp for nowait
• Barrière de synchronisation explicite
• pragma omp barrier
• Compilation conditionnelle
• ifdef _OPENMP

33
Parallélisme fonctionnel

• OpenMP permet deffectuer des parties de code
  différentes en parallèle
• pragma omp parallel sections
• pragma omp section
• pragma omp parallel sections
• pragma omp section
• Fonction_1
• pragma omp section
• Fonction_2

Effectués par des threads différents en parallèle
34
Sommaire

• OpenMP -gt mémoire partagée -gt fork/join
• Souvent utilisé pour le parallélisme de données,
  mais permet aussi le parallélisme fonctionnel
• Relativement confortable pour le programmeur
• Les synchronisations doivent tout de même être
  bien gérées
• www.openmp.org