OpenMP - unistra.fricps.u-strasbg.fr/~bastoul/teaching/openmp/bastoul_cours_openmp.pdf · I 1997OpenMP 1.0 pour Fortran, C/C++ en 1998 I 2000OpenMP 2.0 parallélisation de constructions

OpenMP

Cédric [email protected]

Université de Strasbourg

[email protected]

Introduction OpenMP

Utilisation du support de cours

Ce support est construit comme un portailI Liens vers l’extérieur ou l’intérieur du document

I Suivez-les pour avoir plus de détailI Retour dans l’historique de navigation interne : symbole C

I Chaque code est accessible par une balise [code]

I Balises situées en haut à droite du code ou de la pageI Ne faites pas de copie depuis le PDF

I Accès au détail de chaque concept par une balise [doc]

I Lien vers la bonne page du document de la norme OpenMPI À consulter en cas de doute ou si le support ne suffit pas

C 2

http://icps.u-strasbg.fr/~bastoul/teaching/openmp/codes/directive_parallel.c

http://www.openmp.org/mp-documents/openmp-4.5.pdf#page=35

Introduction OpenMP

Références

Ce cours est librement basé sur les supports suivants, qu’onutilisera parfois directement en séance :

Standard OpenMP 4.5www.openmp.org/mp-documents/openmp-4.5.pdf

Cours OpenMP Oracle de R. van der Paswww.openmp.org/mp-documents/ntu-vanderpas.pdf

Cours OpenMP IDRIS de J. Chergui et P.-F. Lavalléewww.idris.fr/data/cours/parallel/openmp/IDRIS_OpenMP_cours.pdf

Tutoriel OpenMP de B. Barneycomputing.llnl.gov/tutorials/openMP

Livre de B. Chapman, G. Jost et R van der Pas UsingOpenMP MIT Press, 2008

C 3

www.openmp.org/mp-documents/openmp-4.5.pdf

www.openmp.org/mp-documents/ntu-vanderpas.pdf

www.idris.fr/data/cours/parallel/openmp/IDRIS_OpenMP_cours.pdf

computing.llnl.gov/tutorials/openMP

Introduction OpenMP

Un mot sur la situation actuelle

Cet ordinateur :

2.7 milliards de transistors

5 types de parallélisme

17 types de mémoire

Au moins 4 modèles deprogrammation + APIs

CORE

CORE

CORE

CORE

6 Mio L3 Cache

Intel Core i7 3720QM

Registres

32 Kio L1 I-cache

32 Kio L1 D-cache

256 Kio L2 cache

Vecteurs AVX 256 bits

nVidia GT 650M

CORE CORE

CORE

CORE CORE

…

…

…

…384 cores

64k registres (32 bits)

Mémoire locale

48 Kio/core mémoire partagée

1 Gio VRAMMémoire globale

Mémoire constantes

Mémoire textures

8 Kio mémoire cache constantes

8 Kio mémoire cache textures

16 Gio DRAM

ILP (pipeline 4 voies)

Pipeline à 14 étages

Samsung 830 500 Go SSD

256 Mio Cache

C 4

Introduction OpenMP

« Open Multi-Processing » API (Application ProgrammingInterface) standard pour la programmation d’applicationsparallèles sur architectures à mémoire partagée

Programmation basée sur les threads

Directives pour les opérations vectorielles (OpenMP 4.x)

Directives pour les accélérateurs matériels (OpenMP 4.x)

I Standard industriel mature et répandu

I Bonne performance si on s’y prend bien

I Effort de programmation minimal

I Portable

C 5

Introduction OpenMP

HistoriqueArchitectures SMP (« Symmetric Multiprocessing » ou « SharedMemory multiProcessor ») depuis l’IBM System/360 modèle 67(1966) programmées d’abord par des directives ad hoc

I 1991 Le groupe industriel Parallel Computing Forumdéfinit un ensemble de directives pour leparallélisme de boucles pour Fortran(jamais normalisé)

I 1997 OpenMP 1.0 pour Fortran, C/C++ en 1998

I 2000 OpenMP 2.0 parallélisation de constructions deFortran 1995

I 2008 OpenMP 3.0 concept de tâche

I 2013 OpenMP 4.0 SIMD, accélérateurs, etc.

I 2015 OpenMP 4.5 mapping de données, doacross, etc.C 6

Introduction OpenMP

Principe

Ajouter au code des directives pour indiquer au compilateur :

Quelles sont les instructions à exécuter en parallèle

Comment distribuer les instructions et les données entreles différents threads

I En général, les directives sont facultatives (le programmeest sémantiquement équivalent avec ou sans)

I La détection ou l’extraction du parallélisme est laissée à lacharge du programmeur

I L’impact sur le code original séquentiel est souvent minime

I Mais pour gagner en performance il faut travailler un peu !

C 7

Introduction OpenMP

Positionnement

Principaux modèles de programmation parallèle :Architectures à mémoire partagéeI Intrinsics instructions vectorielles assembleur (Intel SSE2,

ARM NEON) très bas niveauI Posix Threads bibliothèque standardisée, bas niveauI OpenMP API standard de faitI CUDA plateforme propriétaire pour accélérateursI OpenCL API et langage pour SMP + accélérateurs

Architectures à mémoire distribuéeI Sockets bibliothèque standardisée, bas niveauI MPI Message Passing Interface, bibliothèque standard de

fait pour les architectures à mémoire distribuée (fonctionneaussi sur les SMP), remaniement important du code

C 8

Introduction OpenMP

Exemple : produit scalaire séquentiel [code]

#include <stdio.h>#define SIZE 256

int main() {double sum, a[SIZE], b[SIZE];

// Initializationsum = 0.;for (size_t i = 0; i < SIZE; i++) {

a[i] = i * 0.5;b[i] = i * 2.0;

}

// Computationfor (size_t i = 0; i < SIZE; i++)

sum = sum + a[i]*b[i];

printf("sum = %g\n", sum);return 0;

}

C 9

http://icps.u-strasbg.fr/~bastoul/teaching/openmp/codes/dot_sequential.c

Introduction OpenMP

Exemple : produit scalaire MPI [code]

#include <stdio.h>#include "mpi.h"#define SIZE 256

int main(int argc , char* argv[]) {int numprocs , my_rank , my_first , my_last;double sum, sum_local , a[SIZE], b[SIZE];MPI_Init(&argc , &argv);MPI_Comm_size(MPI_COMM_WORLD , &numprocs);MPI_Comm_rank(MPI_COMM_WORLD , &my_rank);my_first = my_rank * SIZE/numprocs;my_last = (my_rank + 1) * SIZE/numprocs;

// Initializationsum_local = 0.;for (size_t i = 0; i < SIZE; i++) {

a[i] = i * 0.5;b[i] = i * 2.0;

}

// Computationfor (size_t i = my_first; i < my_last; i++)

sum_local = sum_local + a[i]*b[i];MPI_Allreduce(&sum_local , &sum, 1, MPI_DOUBLE , MPI_SUM , MPI_COMM_WORLD);

if (my_rank == 0)printf("sum = %g\n", sum);

MPI_Finalize();return 0;

}

C 10

http://icps.u-strasbg.fr/~bastoul/teaching/openmp/codes/dot_mpi.c

Introduction OpenMP

Exemple : produit scalaire Pthreads [code]

#include <stdio.h>#include <pthread.h>#define SIZE 256#define NUM_THREADS 4#define CHUNK SIZE/NUM_THREADS

int id[NUM_THREADS];double sum, a[SIZE], b[SIZE];pthread_t tid[NUM_THREADS];pthread_mutex_t mutex_sum;

void* dot(void* id) {size_t i;int my_first = *(int*)id * CHUNK;int my_last = (*(int*)id + 1) * CHUNK;double sum_local = 0.;

// Computationfor (i = my_first; i < my_last; i++)

sum_local = sum_local + a[i]*b[i];

pthread_mutex_lock(&mutex_sum);sum = sum + sum_local;pthread_mutex_unlock(&mutex_sum);return NULL;

}

int main() {size_t i;

// Initializationsum = 0.;for (i = 0; i < SIZE; i++) {

a[i] = i * 0.5;b[i] = i * 2.0;

}

pthread_mutex_init(&mutex_sum , NULL);

for (i = 0; i < NUM_THREADS; i++) {id[i] = i;pthread_create(&tid[i], NULL , dot,

(void*)&id[i]);}

for (i = 0; i < NUM_THREADS; i++)pthread_join(tid[i], NULL);

pthread_mutex_destroy(&mutex_sum);


}

C 11

http://icps.u-strasbg.fr/~bastoul/teaching/openmp/codes/dot_pthreads.c

Introduction OpenMP

Rappel : produit scalaire séquentiel [code]




a[i] = i * 0.5;b[i] = i * 2.0;

}

// Computationfor (size_t i = 0; i < SIZE; i++)

sum = sum + a[i]*b[i];


}

C 12

http://icps.u-strasbg.fr/~bastoul/teaching/openmp/codes/dot_sequential.c

Introduction OpenMP

Exemple : produit scalaire OpenMP [code]




a[i] = i * 0.5;b[i] = i * 2.0;

}

// Computation#pragma omp parallel for reduction(+:sum)for (size_t i = 0; i < SIZE; i++) {

sum = sum + a[i]*b[i];}


}

C 13

http://icps.u-strasbg.fr/~bastoul/teaching/openmp/codes/dot_openmp.c

Introduction OpenMP

OpenMP API1 Directives pour expliciter le

parallélisme, lessynchronisations et le statutdes données (privées,partagées...)

2 Bibliothèque pour desfonctionnalités spécifiques(informations dynamiques,actions sur le runtime...)

3 Variables d’environnementpour influer sur le programmeà exécuter (nombre dethreads, stratégiesd’ordonnancement...)

Compilation

Édition de liens

Exécution

Directives#pragma omp

Bibliothèque#include <omp.h>

Variables d’environnement

OMP_

Programme C/C++ OpenMP API

C 14

Introduction OpenMP

Modèle d’exécution OpenMP

1 L’utilisateur introduit desdirectives établissant desrégions parallèles

2 Durant l’exécution, leurcomportement respecte lemodèle fork-join :

Le thread maître crée desthreads travailleurs et formeune équipe avec euxLes threads travailleurs seterminent avec la régionparallèleLe thread maître continueson exécution

Régionparallèle

Fork

Join

Thread maître

Threads travailleurs

Équipe de threads

C 15

Introduction OpenMP

Modèle mémoire OpenMPTous les threads ont accès àla même mémoire partagée

Chaque thread possède sapropre mémoire privée

Les données partagées sontaccessibles par tous lesthreads

Les données privées sontaccessibles seulement par lethread correspondant

Les transferts de donnéessont transparents pour leprogrammeur

Thread

Mémoire privée

Thread

Mémoire privée

Thread

Mémoire privée

Mémoire partagée

Vue temporaire

Vue temporaire

Vue temporaire

C 16

Directives OpenMP OpenMP

Directives OpenMP

C 17


Principales directives OpenMP

Construction de régions parallèlesI parallel : crée une région parallèle sur le modèle fork-join

Partage du travailI for : partage des itérations d’une boucle parallèleI sections : définit des blocs à exécuter en parallèleI single : déclare un bloc à exécuter par un seul thread

SynchronisationI master : déclare un bloc à exécuter par le thread maîtreI critical : bloc à n’exécuter qu’un thread à la foisI atomic : instruction dont l’écriture mémoire est atomiqueI barrier : attente que tous les threads arrivent à ce point

Gestion de tâchesI task : déclaration d’une tâche filleI taskwait : attente de la fin des tâches filles

C 18


Directives OpenMP

Format des directives en C/C++ [doc]

#pragma omp d i r e c t i v e [ c lause [ clause ] . . . ]

Formées de quatres parties :1 La sentinelle : #pragma omp2 Un nom de directive valide3 Une liste de clauses optionnelles (infos supplémentaires)4 Un retour à la ligne

Règles générales :

Attention à respecter la casse

Une directive s’applique sur le bloc de code suivant

Les directives longues peuvent se poursuivre à la ligne enutilisant le caractère antislash « \ » en fin de ligne

C 19


Directives OpenMP – Construction de régions parallèles OpenMP

Directives OpenMPConstruction de régions parallèles

C 20


Directive parallel (1/2)

Format de la directive parallel en C/C++ [doc]

#pragma omp p a r a l l e l [ c lause [ c lause ] . . . ]{

/ / Région p a r a l l è l e}

Fonctionnement :

Quand un thread rencontre une directive parallel, il créeune équipe de threads dont il devient le thread maître denuméro 0 ; les threads de l’équipe exécutent tous le bloc

Le nombre de threads dépend, dans l’ordre, de l’évaluationde la clause if, de la clause num_threads, de la primitiveomp_set_num_threads(), de la variable d’environnementOMP_NUM_THREADS, de la valeur par défaut

Il existe une barrière implicite à la fin de la région parallèleC 21



Directive parallel (2/2)

I Par défaut, le statut des variables est partagé dans larégion parallèle

I Cependant, si la région contient des appels de fonction,leurs variables locales et automatiques sont de statut privé

I Il est interdit d’effectuer des branchements (goto) depuisou vers une région parallèle

I Clauses possibles : if, num_threads, private, shared,default, firstprivate, reduction, copyin

C 22


Clause if

Format de la clause if en C/C++ [doc]

i f ( /∗ Expression s c a l a i r e ∗ / )

I Quand elle est présente, une équipe de threads n’est crééeque si l’expression scalaire est différente de zéro, sinon larégion est exécutée séquentiellement par le thread maître

Exemple d’utilisation de la clause if#include < s t d i o . h>#define PARALLEL 1 / / 0 pour sé quen t ie l , != 0 pour p a r a l l è l e

i n t main ( ) {#pragma omp p a r a l l e l i f (PARALLEL)p r i n t f ( " Hel lo , openMP \ n " ) ;return 0;

}

C 23



Clause num_threads

Format de la clause num_threads en C/C++ [doc]

num_threads ( /∗ Expression e n t i è re ∗ / )

I Spécifie le nombre de threads de l’équipe qui exécutera laprochaine région parallèle

I L’expression entière doit s’évaluer en une valeur entièrepositive

C 24



ExerciceUn premier exemple [code]

#include < s t d i o . h>

i n t main ( ) {#pragma omp p a r a l l e lp r i n t f ( " Hel lo , \ n " ) ;p r i n t f ( " wor ld \ n " ) ;return 0;

}

I Compilez ce programme sans et avec l’option -fopenmp

I Exécutez ce programme dans les deux cas

I Quel est le nombre de threads par défaut ? Est-ceraisonnable ?

I Changez le nombre de threads utilisé pour exécuter votreprogramme

C 25

http://icps.u-strasbg.fr/~bastoul/teaching/openmp/codes/directive_parallel.c

Directives OpenMP – Partage de travail OpenMP

Directives OpenMPPartage de travail

C 26


Directives de partage de travailI Incluses dans les régions parallèles

I Doivent être rencontrées par tous les threads ou aucun

I Répartissent le travail entre les différents threads

I Impliquent une barrière à la fin de la construction (sauf si laclause nowait est spécifiée)

Thread maître

Équipe de threads

Iterationsfor

for : répartit les itérationsd’une boucle parallèle

Thread maître

Équipe de threads

sections

sections : répartit suivant dessections prédéfinies

Thread maître

Équipe de threads

single

single : un seul thread exé-cute une section prédéfinie

C 27


Directive forFormat de la directive for en C/C++ [doc]

#pragma omp for [ c lause [ c lause ] . . . ]for ( . . . )

. . .

I Indique que les itérations de la boucle qui suit la directivedoivent être exécutées en parallèle par l’équipe de threads

I La variable d’itération est privée par défautI Les boucles doivent avoir une forme itérative simple [doc]

I Les bornes doivent être les mêmes pour tous les threadsI Les boucles infinies ou while ne sont pas supportées

I Rappel : le programmeur est responsable de la sémantique

I Clauses possibles : schedule, ordered, private,firstprivate, lastprivate, reduction, collapse,nowait

C 28




Exercice

I Écrire un programme C effectuant la somme de chaqueélément d’un tableau et d’un scalaire dans un deuxièmetableau

I Parallélisez ce programme avec OpenMP

C 29


Clause schedule (1/2)

Format de la clause schedule en C/C++ [doc]

schedule ( type [ , chunk ] )

I Spécifie la politique de partage des itérations

I 5 types possibles [doc] :

static Les itérations sont divisées en blocs de chunkitérations consécutives ; les blocs sont assignésaux threads en round-robin ; si chunk n’est pasprécisé, des blocs de tailles similaires sont créés,un par thread

dynamic Chaque thread demande un bloc de chunkitérations consécutives dès qu’il n’a pas de travail(le dernier bloc peut être plus petit) ; si chunk n’estpas précisé, il vaut 1

C 30




Clause schedule (2/2)

guided Même chose que dynamic mais la taille des blocsdécroît exponentiellement ; si chunk vaut plus que1, il correspond au nombre minimum d’itérationsdans un chunk (sauf pour le dernier)

runtime Le choix de la politique est reporté au moment del’exécution, par exemple par la variabled’environnement OMP_SCHEDULE

auto Le choix de la politique est laissé au compilateuret/ou au runtime

I Le choix de la politique est critique pour les performances

C 31


Exercice (1/2)

Lisez, étudiez, compilez et exécutez le code suivant [code]#include <stdio.h>#include <omp.h>#define SIZE 100#define CHUNK 10

int main() {int tid;double a[SIZE], b[SIZE], c[SIZE];

for (size_t i = 0; i < SIZE; i++)a[i] = b[i] = i;

#pragma omp parallel private(tid){

tid = omp_get_thread_num();if (tid == 0)

printf("Nb threads = %d\n", omp_get_num_threads());printf("Thread %d: starting...\n", tid);

#pragma omp for schedule(dynamic, CHUNK)for (size_t i = 0; i < SIZE; i++) {

c[i] = a[i] + b[i];printf("Thread %d: c[%2zu] = %g\n", tid, i, c[i]);

}}return 0;

}

C 32

http://icps.u-strasbg.fr/~bastoul/teaching/openmp/codes/clause_schedule.c


Exercice (2/2)

I Analysez le programme : quelles sont les instructionsexécutées par tous les threads ? Par un seul thread ?

I Exécutez le programme plusieurs fois. Que penser del’ordre d’exécution des instructions ?

I Redirigez la sortie de l’exécutable sur l’utilitaire sort.Exécutez et observez la répartition des itérations.

I Recommencer plusieurs fois. La répartition est-elle stable ?

I Changer la politique d’ordonnancement par static.Exécutez plusieurs fois. La répartition est-elle stable ?

I Discutez des effets de la politique d’ordonnancement surles performances.

C 33


Clause collapseFormat de la clause collapse en C/C++ [doc]

collapse ( /∗ Expression e n t i è re s t r i c t e m e n t p o s i t i v e ∗ / )

I Spécifie le nombre de boucles associées à une directivefor (1 par défaut)

I Si l’expression entière vaut plus que 1, les itérations detoutes les boucles associées sont groupées pour former ununique espace d’itération qui sera réparti entre les threads

I L’ordre des itérations de la boucle groupée correspond àl’ordre des itérations des boucles originales

#pragma omp for collapse ( 2 )for ( i = 0 ; i < 10; i ++)

for ( j = 0 ; j < 10; j ++)f ( i , j ) ;

≡#pragma omp forfor ( i = 0 ; i < 100; i ++)

f ( i /10 , i %10);

C 34



Clause nowait

Format de la clause nowait en C/C++nowait

I Retire la barrière implicite en fin de construction de partagede travail

I Les threads finissant en avance peuvent exécuter lesinstructions suivantes sans attendre les autres

I Le programmeur doit s’assurer que la sémantique duprogramme est préservée

C 35


Exercice (1/2)

Lisez, étudiez, compilez et exécutez le code suivant [code]#include <stdio.h>#define SIZE 100

int main() {double a[SIZE], b[SIZE], c[SIZE], d[SIZE];

for (size_t i = 0; i < SIZE; i++)a[i] = b[i] = i;

#pragma omp parallel{#pragma omp for schedule(static) nowaitfor (size_t i = 0; i < SIZE; i++)

c[i] = a[i] + b[i];

#pragma omp for schedule(static)for (size_t i = 0; i < SIZE; i++)

d[i] = a[i] + c[i];}

for (size_t i = 0; i < SIZE; i++)printf("%g ", d[i]);

printf("\n");return 0;

}

C 36

http://icps.u-strasbg.fr/~bastoul/teaching/openmp/codes/clause_nowait.c


Exercice (2/2)

I Exécutez le programme plusieurs fois. Les résultatssemblent-ils incohérents ?

I Analysez le programme : quelles itérations vont êtreexécutées par quels threads (le détail de la politiquestatic dans le standard OpenMP vous aidera [doc]) ?

I Après analyse, l’utilisation de la clause nowait voussemble-t-elle raisonnable ?

I Changez la politique d’ordonnancement pour la secondeboucle à guided.

I Exécutez le programme plusieurs fois. Les résultatssemblent-ils incohérents ? Si vous n’avez pas vu leproblème, cherchez mieux ;-) !

C 37



Directive sections

Format de la directive sections en C/C++ [doc]

#pragma omp sections [ c lause [ c lause ] . . . ]{

#pragma omp section/ / Bloc 1. . .#pragma omp section/ / Bloc N

}

I Indique que les instructions dans les différentes sectionsdoivent être exécutées en parallèle par l’équipe de threads

I Chaque section n’est exécutée qu’une seule fois

I Les sections doivent être définies dans l’étendue statique

I Clauses possibles : private, firstprivate,lastprivate, reduction, nowait

C 38



Directive single

Format de la directive single en C/C++ [doc]

#pragma omp single [ c lause [ c lause ] . . . ]{

/ / Bloc}

I Spécifie que le bloc d’instructions suivant la directive seraexécuté par un seul thread

I On ne peut pas prévoir quel thread exécutera le bloc

I Utile pour les parties de code non thread-safe (par exempleles entrées/sorties)

I Clauses possibles : private, firstprivate,copyprivate, nowait

C 39



Raccourcis parallel for/sections

Format de la directive parallel for en C/C++#pragma omp p a r a l l e l for [ c lause [ c lause ] . . . ]for ( . . . )

. . .

Format de la directive parallel sections en C/C++#pragma omp p a r a l l e l sections [ c lause [ c lause ] . . . ]{

#pragma omp section/ / Bloc 1. . .#pragma omp section/ / Bloc N

}

I Créent une région parallèle avec une seule construction

I Clauses possibles : union des clauses sauf nowaitC 40


Directives orphelines

L’influence d’une région parallèleporte sur le bloc de code qui la suitdirectement (étendue statique) etsur les fonctions appelées dedans(étendue dynamique)

I Directives en dehors del’étendue statique dites« orphelines »

I Liées à la région parallèle quiles exécute immédiatement

I Ignorées à l’exécution si nonliées à une région parallèle

omp for orphelin [code]

#include < s t d i o . h>#define SIZE 1024

void i n i t ( i n t∗ vec ) {size_t i ;#pragma omp forfor ( i = 0 ; i < SIZE ; i ++)

vec [ i ] = 0 ;}

i n t main ( ) {i n t vec [ SIZE ] ;#pragma omp p a r a l l e li n i t ( vec ) ;return 0;

}

C 41

http://icps.u-strasbg.fr/~bastoul/teaching/openmp/codes/directive_orpheline.c


Directives imbriquéesIl est possible d’imbriquer les régions parallèles

I L’implémentation peut ignorer les régions internes

I Niveau d’imbrication a priori arbitraire

I Attention aux performances

Directives imbriquées [code]

#include < s t d i o . h>#include <omp.h>

i n t main ( ) {omp_set_nested ( 1 ) ;#pragma omp p a r a l l e l num_threads ( 2 ){

#pragma omp p a r a l l e l num_threads ( 2 )p r i n t f ( " Hel lo , wor ld \ n " ) ;

}return 0;

}

C 42

http://icps.u-strasbg.fr/~bastoul/teaching/openmp/codes/directive_imbriquees.c

Directives OpenMP – Clauses de statut des variables OpenMP

Directives OpenMPClauses de statut des variables

C 43


Clauses de statut des variables

OpenMP cible les architectures à mémoire partagée ; laplupart des variables sont donc partagées par défautOn peut contrôler le statut de partage des donnéesI Quelles données des sections séquentielles sont

transférées dans les régions parallèles et commentI Quelles données seront visibles par tous les threads ou

privées à chaque thread

Principales clauses :I private : définit une liste de variables privéesI firstprivate : private avec initialisation automatiqueI lastprivate : private avec mise à jour automatiqueI shared : définit une liste de variables partagéesI default : change le statut par défautI reduction : définit une liste de variables à réduire

C 44


Clause private

Format de la clause private en C/C++ [doc]

private ( /∗ L i s t e de v a r i a b l e s ∗ / )

I Définit une liste de variables à placer en mémoire privée

I Il n’y a pas de lien avec les variables originales

I Toutes les références dans la région parallèle seront versles variables privées

I Un thread ne peut pas accéder les variables privées d’unautre thread

I Les modifications d’une variable privée sont visiblesseulement par le thread propriétaire

I Les valeurs de début et de fin sont indéfinies

C 45



ExerciceExemple d’utilisation de la clause private [code]

#include < s t d i o . h>#include <un is td . h>#include < s t d l i b . h>

i n t main ( ) {i n t va l ;#pragma omp p a r a l l e l pr ivate ( va l ){

va l = rand ( ) ;s leep ( 1 ) ;p r i n t f ( "My va l : %d \ n " , va l ) ;

}return 0;

}

I Compilez et exécutez ce code avec et sans private(val)

I Qu’observez-vous et pourquoi ?

I Est-ce risqué même avec la clause private ?C 46

http://icps.u-strasbg.fr/~bastoul/teaching/openmp/codes/clause_private.c


Clause firstprivate

Format de la clause firstprivate en C/C++ [doc]

f i r s t p r i v a t e ( /∗ L i s t e de v a r i ab l e s ∗ / )

I Combine le comportement de la clause private avec uneinitialisation automatique

I Les variables listées sont initialisées avec leur valeur aumoment de l’entrée dans la région parallèle

C 47



Clause lastprivate

Format de la clause lastprivate en C/C++ [doc]

l as tpr iva te ( /∗ L i s t e de v a r i ab l e s ∗ / )

I Combine le comportement de la clause private avec unemise à jour automatique des variables originales à la fin dela région parallèle

I Les variables listées sont mises à jour avec la valeur de lavariable privée correspondante à la fin du thread quiexécute soit la dernière itération d’une boucle soit ladernière section par rapport à l’exécution séquentielle

C 48



Clause shared

Format de la clause shared en C/C++ [doc]

shared ( /∗ L i s t e de v a r i a b l e s ∗ / )

I Définit une liste de variables à placer en mémoire partagée

I Il n’y a qu’une instance de chaque variable partagée

I Tous les threads d’une même équipe peuvent accéder auxvariables partagées simultanément (sauf si une directiveOpenMP l’interdit, comme atomic ou critical)

I Les modifications d’une variable partagée sont visibles partous les threads de l’équipe (mais pas toujoursimmédiatement, sauf si une directive OpenMP le précise,comme flush)

C 49



Clause default

Format de la clause default en C/C++ [doc]

defaul t ( shared | none )

I Permet à l’utilisateur de changer le statut par défaut desvariables de la région parallèle (hors variables locales etautomatiques des fonctions appelées)

I Choisir none impose au programmeur de spécifier le statutde chaque variableI Bien pour éviter les variables partagées par erreur

C 50



Clause reduction

Format de la clause reduction en C/C++ [doc]

reduction ( operateur : /∗ l i s t e de v a r i a b l es ∗ / )

I Réalise une réduction sur les variables de la liste

I Une copie privée de chaque variable dans la liste est crééepour chaque thread ; à la fin de la construction, l’opérateurde réduction est appliqué aux variables privées et lerésultat est écrit dans la variable partagée correspondante

I operateur peut valoir +, -, *, &, |, ˆ, && ou ||

I Les variables dans la liste doivent être partagées

I Attention à la stabilité numérique

I La variable ne peut être utilisée que dans des instructionsde forme particulière (voir standard OpenMP, page 167)

C 51



Exercice

I Écrire un programme C calculant la somme des élémentsd’un tableau.

I Parallélisez ce programme avec OpenMP.

I Comparer le temps d’exécution séquentielle et le tempsd’exécution parallèle.

C 52


Directive threadprivateFormat de la directive threadprivate en C/C++ [doc]

/ / Dé c l a r a t i o n de v a r i a b l e s g loba les e t / ou s t a t i q u e s#pragma omp threadprivate ( /∗ L i s t e de v a r i a b l e s g loba les / s t a t i q ue s ∗ / )

I Spécifie que les variables listées seront privées etpersistantes à chaque thread au travers de l’exécution demultiples régions parallèles

I La valeur des variables n’est pas spécifiée dans la premièrerégion parallèle sauf si la clause copyin est utilisée

I Ensuite, les variables sont préservées

I La directive doit suivre la déclaration des variables globalesou statiques concernées

I Le nombre de threads doit être fixe (omp_set_dynamic(0))

I Clauses possibles : aucuneC 53



ExerciceÉtudiez, exécutez ce code et discutez les résultats [code]

#include < s t d i o . h>#include <omp.h>

i n t t i d , t p r i v a t e , r p r i v a t e ;#pragma omp threadprivate ( t p r i v a t e )

i n t main ( ) {/ / On i n t e r d i t e x p l i c i t e m e n t les threads dynamiquesomp_set_dynamic ( 0 ) ;

p r i n t f ( "Région p a r a l l è l e 1 \ n " ) ;#pragma omp p a r a l l e l pr ivate ( t i d , r p r i v a t e ){

t i d = omp_get_thread_num ( ) ;t p r i v a t e = t i d ;r p r i v a t e = t i d ;p r i n t f ( " Thread %d : t p r i v a t e=%d r p r i v a t e=%d \ n " , t i d , t p r i v a t e , r p r i v a t e ) ;

}

p r i n t f ( "Région p a r a l l è l e 2 \ n " ) ;#pragma omp p a r a l l e l pr ivate ( t i d , r p r i v a t e ){

t i d = omp_get_thread_num ( ) ;p r i n t f ( " Thread %d : t p r i v a t e=%d r p r i v a t e=%d \ n " , t i d , t p r i v a t e , r p r i v a t e ) ;

}return 0;

}

C 54

http://icps.u-strasbg.fr/~bastoul/teaching/openmp/codes/directive_threadprivate.c


Clause copyin

Format de la clause copyin en C/C++ [doc]

copyin ( /∗ L i s t e de v a r i a b l e s dé c l a r ées t h r e a d p r i v a t e ∗ / )

I Spécifie que les valeurs des variables threadprivate duthread maître présentes dans la liste devront être copiéesdans les variables privées correspondantes des threadstravailleurs en début de région parallèle

C 55



Clause copyprivate

Format de la clause copyprivate en C/C++ [doc]

copyprivate ( /∗ L i s t e de v a r i ab l e s dé c l a r ées p r i v a t e ∗ / )

I Demande la copie des valeurs des variables privées d’unthread dans les variables privées correspondantes desautres threads d’une même équipe

I Utilisable seulement avec la directive single

I Ne peut être utilisée en conjonction avec la clause nowait

I La copie a lieu après l’exécution du bloc associé à ladirective single et avant la sortie de barrière de fin de bloc

C 56


Directives OpenMP – Synchronisation OpenMP

Directives OpenMPSynchronisation

C 57


Erreur type : data race

Risque de data race [code]

#include < s t d i o . h>#define MAX 10000

i n t main ( ) {size_t i ;i n t n = 0;

#pragma omp p a r a l l e l forfor ( i = 0 ; i < MAX; i ++)

n++;

p r i n t f ( " n = %d \ n " , n ) ;return 0;

}

À l’exécution du programme ci-contre, la valeur affichée peut êtreinférieure à MAX :

I Accès concurents à n

I Incrémentation non atomique

I Incrémentations « perdues »

Thread A Thread Bload R1, @nadd R1, 1store @n, R1

load R1, @nadd R1, 1store @n, R1

Le thread B interrompt le thread ALe thread A écrase la valeur écrite par B

C 58

http://icps.u-strasbg.fr/~bastoul/teaching/openmp/codes/bug_race.c


Erreur type : défaut de cohérence

Risque d’incohérence [code]

#include < s t d i o . h>

i n t main ( ) {i n t f i n = 0 ;

#pragma omp p a r a l l e l sections{

#pragma omp section{

while ( ! f i n )p r i n t f ( " Pas f i n i \ n " ) ;

}#pragma omp section{

f i n = 1 ;p r i n t f ( " F i n i \ n " ) ;

}}return 0;

}

À l’exécution du programme ci-contre, « Pas fini » peut être af-fiché après « Fini » :

I Interruption de la premièresection entre l’évaluation defin et l’affichage (data race)

I Utilisation d’une vuetemporaire obsolète de lamémoire partagée par lethread exécutant la premièresection (défaut de cohérence)

C 59

http://icps.u-strasbg.fr/~bastoul/teaching/openmp/codes/bug_coherence.c


Erreur type : non synchronisation

Non synchronisation [code]

#include < s t d i o . h>#include <omp.h>i n t main ( ) {

double t o t a l , part1 , par t2 ;#pragma omp p a r a l l e l \

num_threads ( 2 ){

i n t t i d ;t i d = omp_get_thread_num ( ) ;i f ( t i d == 0)

par t1 = 25;i f ( t i d == 1)

par t2 = 17;i f ( t i d == 0) {

t o t a l = par t1 + par t2 ;p r i n t f ( "%g \ n " , t o t a l ) ;

}}return 0;

}

À l’exécution du programme ci-contre, la valeur affichée peut êtredifférente de 42

I Le thread 0 n’attend pas lethread 1 pour faire le calcul etl’affichage

C 60

http://icps.u-strasbg.fr/~bastoul/teaching/openmp/codes/bug_synchronisation.c


Mécanismes de synchronisation

Barrière pour attendre que tous les threads aient atteint unpoint donné de l’exécution avant de continuerI Implicite en fin de construction OpenMP (hors nowait)I Directive barrier

Ordonnancement pour garantir un ordre global d’exécutionI Clause ordered

Exclusion mutuelle pour assurer qu’une seule tâche à lafois exécute une certaine partie de codeI Directive criticalI Directive atomic

Attribution pour affecter un traitement à un thread donnéI Directive master

Verrou pour ordonner l’exécution d’au moins deux threadsI Fonctions de la bibliothèque OpenMP

C 61


Directive barrier

Format de la directive barrier en C/C++ [doc]

#pragma omp barr ie r

I Synchronisation entre tous les threads d’une équipe

I Quand un thread arrive à la directive barrier il attend quetous les autres threads y soient arrivés ; quand cela arrive,les threads poursuivent leur exécution en parallèle

I Doit être rencontrée par tous les threads ou aucun :attention aux interblocages (deadlocks)

I Clauses possibles : aucune

C 62



Clause orderedFormat de la directive ordered en C/C++ [doc]

#pragma omp ordered{

/ / Bloc}

I Seulement dans un for où on aindiqué la clause ordered

I Spécifie que les exécutions dubloc suivant la directive devrontrespecter l’ordre séquentiel

I Les threads s’attendent si besoinpour respecter cet ordre

I Les parties de la boucle parallèlenon gardées par cette directivepeuvent s’exécuter en parallèle

Thread maîtreÉquipe de threads

for ordered

C 63



Directive criticalFormat de la directive critical en C/C++ [doc]

#pragma omp c r i t i c a l [nom]{

/ / Bloc}

I Spécifie que le bloc d’instructions suivant la directive doitêtre exécuté un seul thread à la fois

I Si un thread exécute un bloc protégé par la directivecritical et qu’un second arrive à ce bloc, alors le seconddevra attendre que le premier ait terminé avant decommencer l’exécution du bloc

I Les blocs précédés de directives critical avec un mêmenom sont exécutés en exclusion mutuelle

I Clauses possibles : aucuneC 64



Directive atomic

Format de la directive atomic en C/C++ [doc]

#pragma omp atomic/ / I n s t r u c t i o n d ’ a f f e c t a t i o n

I Spécifie que l’affectation (évaluation et écriture de lavariable affectée) suivant la directive doit être réalisée demanière atomique

I Plus efficace que la directive critical dans ce cas

I Formes d’instruction particulières : voir standard OpenMPpour les détails [doc]


C 65




Directive master

Format de la directive master en C/C++ [doc]

#pragma omp master{

/ / Bloc}

I Spécifie que le bloc d’instructions suivant la directive seraexécuté par le seul thread maître, les autres threadspassent cette section de code

I Pas de barrière implicite ni à l’entrée ni à la fin du bloc


C 66



Directive flush

Format de la directive flush en C/C++ [doc]

#pragma omp flush ( /∗ L i s t e de v a r i a b l e s par tagées ∗ / )

I Spécifie que la vue temporaire du thread qui la rencontredoit être cohérente avec l’état de la mémoire partagée pourchaque variable de la liste

I Implicite après une région parallèle, un partage de travail(hors nowait), une section critique ou un verrou

I À faire après écriture dans un thread et avant lecture dansun autre pour partager une variable de manière cohérente

I Indispensable même sur un système à cohérence de cache


C 67



Exercice

Corriger les codes donnés en exemple des erreurs type :

I Data race

I Défaut de cohérence

I Défaut de synchronisation

C 68


Exercice

Parallélisation d’un code à l’état sauvage : dans la nature, lescodes parallélisables sans modifications sont rares !I Récupérez les codes suivants (crédit Dominique Béréziat) :

[code] et [code]I Calcule les points de l’ensemble de MandelbrotI Enregistre le résultat sous forme d’image au format ras

I Lisez ce programme et étudiez son parallélismeI Rendez possible la parallélisation par OpenMP

I Cherchez à avoir une forme itérative acceptable [doc]I Modifiez certains calculs pour rendre le code parallèle

I Implémentez une version parallèle avec OpenMP

C 69

http://icps.u-strasbg.fr/~bastoul/teaching/openmp/codes/mandel.c

http://icps.u-strasbg.fr/~bastoul/teaching/openmp/codes/rasterfile.h

http://fr.wikipedia.org/wiki/Ensemble_de_Mandelbrot

http://www.fileformat.info/format/sunraster/egff.htm


Directives OpenMP – Tâches OpenMP

Directives OpenMPGestion des tâches

C 70


Concept de tâche

Une tâche OpenMP est un bloc de travail indépendant qui devraêtre exécuté par un des threads d’une même équipe

I Les directives de partage de travail créent des tâches demanière implicite

I Il est possible de créer des tâches explicitementI Parallélisation de boucles non-itérativesI Parallélisation de code récursif

I Un « pool » de tâches existe pour chaque région parallèle

I Un thread qui crée une tâche l’ajoute à ce pool ; ce ne serapas nécessairement lui qui l’exécutera

I Les threads exécutent les tâches du pool à la premièrebarrière qu’ils rencontrent

C 71


Directive taskFormat de la directive task en C/C++ [doc]

#pragma omp task [ c lause [ c lause ] . . . ]{

/ / Bloc}

I Crée une nouvelle tâche composée du bloc d’instructionsuivant la directive

I La tâche créée est soit exécutée immédiatement par lethread qui l’a créée (voir clauses), soit ajoutée au pool

I Par défaut variables shared si toujours shared depuis lapremière région parallèle, firstprivate sinon

I Clauses possibles : if (sémantique différente de ladirective parallel), final, untied, default,mergeable, private, firstprivate, shared

C 72



Clauses de la directive taskFormat de la clause if en C/C++ [doc]

i f ( /∗ Expression s c a l a i r e ∗ / )

I Exécution immédiate par le thread si vrai, pool si faux

Format de la clause final en C/C++ [doc]

f i n a l ( /∗ Expression s c a l a i r e ∗ / )

I Les sous-tâches seront intégrées à la tâche si vrai

Format de la clause untied en C/C++ [doc]

untied

I Tout thread peut reprendre la tâche si elle est suspendue

Format de la clause mergeable en C/C++ [doc]

mergeable

I La tâche est combinable si elle est immédiate ou intégréeC 73






Directive taskwait

Format de la directive taskwait en C/C++ [doc]

#pragma omp taskwait

I Spécifie un point d’attente de la terminaison de toutes lessous-tâches créées par le thread rencontrant la directive

I Il s’agît d’une barrière spécifique aux tâches


C 74



Exercice : affichages possibles ? [code 1, 2, 3, 4]

#include <stdio.h>int main() {

#pragma omp parallel{#pragma omp single{

printf("Hello ,\n");printf("world!\n");

}}

return 0;}


#pragma omp parallel{#pragma omp single{#pragma omp taskprintf("Hello ,\n");#pragma omp taskprintf("world!\n");

}}return 0;

}


#pragma omp parallel{#pragma omp single{#pragma omp taskprintf("Hello ,\n");#pragma omp taskprintf("world!\n");printf("Bye\n");

}}

return 0;}


#pragma omp parallel{#pragma omp single{#pragma omp taskprintf("Hello ,\n");#pragma omp taskprintf("world!\n");#pragma omp taskwaitprintf("Bye\n");

}}return 0;

}

C 75

http://icps.u-strasbg.fr/~bastoul/teaching/openmp/codes/directive_task1.c





Exercice

I Parallélisez ce code de calcul des nombres de Fibonacci

I Comparez les performances avec le code séquentiel

Calcul des termes de la suite de Fibonacci [code]

#include < s t d i o . h>#include < s t d l i b . h>

i n t f i b o ( i n t n ) {i f ( n < 2)

return n ;

return f i b o ( n−1) + f i b o ( n−2);}

i n t main ( i n t argc , char∗ argv [ ] ) {i n t n = a t o i ( argv [ 1 ] ) ;p r i n t f ( " f i b o (%d ) = %d \ n " , n , f i b o ( n ) ) ;return 0;

}

C 76

http://icps.u-strasbg.fr/~bastoul/teaching/openmp/codes/fibonacci.c

Bibliothèque OpenMP OpenMP

Bibliothèque OpenMP

C 77


Bibliothèque OpenMP

Fonctions liées à l’environnement d’exécutionI Modification du comportement à l’exécution (e.g., politique

d’ordonnancement)I Surveillance du runtime (e.g., nombre total de threads,

numéro de thread etc.)

Fonctions utilitaires d’intérêt général, même en dehors dela parallélisation car portablesI Mesure du tempsI Mécanisme de verrou

C 78


Préserver l’indépendance à OpenMP_OPENMP défini lorsque le compilateur prend en charge OpenMP

I Utiliser des directives préprocesseur pour écrire un codeavec et sans support d’OpenMP

I Définir des macros pour chaque fonction OpenMP utilisée

Exemple de compilation conditionnelle [code]

#include < s t d i o . h># i f d e f _OPENMP

#include <omp.h>#else

#define omp_get_thread_num ( ) 0#endif

i n t main ( ) {#pragma omp p a r a l l e lp r i n t f ( " He l lo from thread %d \ n " , omp_get_thread_num ( ) ) ;return 0;

}

C 79

http://icps.u-strasbg.fr/~bastoul/teaching/openmp/codes/preprocesseur.c


Fonctions affectant le runtime

void omp_set_num_threads ( i n t n ) ;Fixe le nombre de threads pour laprochaine région parallèle à n

void omp_set_dynamic ( i n t bool ) ;Active ou désactive l’ajustementautomatique du nombre de threads

void omp_set_nested ( i n t bool ) ;Active ou désactive le support derégions parallèles imbriquées

void omp_set_max_active_levels (i n t n ) ;

Fixe le nombre maximum derégions parallèles imbriquables à n

void omp_set_schedule (omp_sched_t type , i n t chunk ) ;

Fixe la politique l’ordonnancementquand runtime a été choisie àtype (1 pour static, 2 pourdynamic, 3 pour guided ou 4 pourauto) et spécifie la valeur de chunk

C 80


Fonctions monitorant le runtime 1/2

i n t omp_get_num_threads ( ) ;Retourne le nombre de threadsdans l’équipe en cours d’exécution

i n t omp_get_dynamic ( ) ;

S’évalue à vrai si l’ajustementautomatique du nombre de threadest activé, à faux sinon

i n t omp_get_nested ( ) ;

S’évalue à vrai si le support derégions parallèles imbriquées estactivé, à faux sinon

i n t omp_get_max_active_levels ( ) ;Retourne le nombre maximum derégions parallèles imbriquables

void omp_get_schedule (omp_sched_t∗ type , i n t∗ chunk ) ;

Retourne le type de la politiqued’ordonnancement et la valeur dechunk au moment de l’appel (voiropm_set_schedule() pour lesvaleurs possibles)

C 81


Fonctions monitorant le runtime 2/2

i n t omp_get_thread_num ( ) ;Retourne le numéro du threadcourant dans l’équipe courante

i n t omp_get_num_procs ( ) ;Retourne le nombre deprocesseurs disponibles

i n t omp_in_parallel ( ) ;

S’évalue à vrai si une régionparallèle est en cours d’exécution, àfaux sinon

i n t omp_in_final ( ) ;S’évalue à vrai si la tâche couranteest final, à faux sinon

Et bien d’autres encore (voir la norme)...

C 82


Fonctions de mesure du temps

double omp_get_wtime ( ) ;

Retourne le temps écoulé ensecondes depuis un temps deréférence

double omp_get_wtick ( ) ;

Retourne le temps écoulé ensecondes entre deux « tops »d’horloge (indique la précision de lamesure du temps)

I Mesures de temps comparables seulement dans un mêmethread

I Fonctions portables très utiles même en dehors duparallélisme

C 83


Verrous OpenMP

Deux types de verrous et leurs fonctions associées :

omp_lock_t pour les verrous simples

omp_nest_lock_t pour les verrous à tours, pouvant êtreverrouillés plusieurs fois par un même thread et devant êtredéverrouillés autant de fois par ce thread pour être levés

I Alternatives plus flexibles à atomic et critical

I Verrous portables entre Unix et Windows

I Attention à bien les initialiser avec les fonctions adaptées

I Attention à ne pas verrouiller plusieurs fois un verrou simple

I Préférer atomic ou critical quand c’est possible

C 84


Fonctions sur les verrous

void omp_init_lock ( omp_lock_t∗ l ) ; Initialise un verrou

void omp_destroy_lock ( omp_lock_t∗ l ) ; Détruit un verrou

void omp_set_lock ( omp_lock_t∗ l ) ;

Positionne un (tour de) verrou, latâche appelante est suspenduejusqu’au verrouillage effectif

void omp_unset_lock ( omp_lock_t∗ l ) ; Libère un (tour de) verrou

i n t omp_test_lock ( omp_lock_t∗ l ) ;

Tente de positionner un verrousans suspendre la tâche ;s’évalue à vrai si la tentativeréussit, à faux sinon

I Partout nest_lock au lieu de lock pour les verrous à tours

C 85


Exemple d’utilisation d’un verrou [code]

#include <stdio.h>#include <omp.h>#define MAX 10int main() {

omp_lock_t lock;omp_init_lock(&lock);

#pragma omp parallel sections{#pragma omp sectionfor (size_t i = 0; i < MAX; i++) {

if (omp_test_lock(&lock)) {printf("Thread A: locked work\n");omp_unset_lock(&lock);

} else {printf("Thread A: alternative work\n");

}}#pragma omp sectionfor (size_t i = 0; i < MAX; i++) {

omp_set_lock(&lock);printf("Thread B: locked work\n");omp_unset_lock(&lock);

}}

omp_destroy_lock(&lock);return 0;

}

C 86

http://icps.u-strasbg.fr/~bastoul/teaching/openmp/codes/lock.c

Variables d’environnement OpenMP OpenMP

Variables d’environnementOpenMP

C 87


Généralités sur les variablesd’environnement

I Variables dynamiques utilisées par les processus pourcommuniquer

I Prises en compte par le runtime OpenMP avec une prioritéplus faible que les fonctions de la bibliothèque elles-mêmesde priorité plus faible que les directives en cas de conflit

I Affichage de la valeur d’une variable NOM_VARUnix : echo $NOM_VARWindows : set %NOM_VAR%

I Affectation d’une valeur VAL à une variable NOM_VARUnix : NOM_VAR=VALWindows : set NOM_VAR=VAL

C 88


Variables d’environnement OpenMP

OMP_NUM_THREADSEntier : nombre de threads à utiliserdans les régions parallèles

OMP_SCHEDULEtype[,chunk] : définit la politiqued’ordonnancement à utiliser, voirclause schedule

OMP_DYNAMICtrue ou false : autorise ou interdit leruntime à ajuster dynamiquement lenombre de threads

OMP_NESTEDtrue ou false : active ou désactive leparallélisme imbriqué

OMP_MAX_ACTIVE_LEVELSEntier : nombre maximum de niveauxactifs de parallélisme imbriqué

OMP_THREAD_LIMITEntier : nombre de threads maximum àutiliser par un programme OpenMP

Et bien d’autres encore (voir la norme)...C 89

conclusion OpenMP

Quelques règles de bonne conduite

I Utiliser la clause default(none)I Pour ne pas déclarer par erreur une variable partagée

I Définir les régions parallèles hors des boucles si possibleI Pour ne pas perdre du temps à créer et détruire les threads

I Ne pas imposer de synchronisations inutilesI Penser à la clause nowait

I Utiliser les synchronisations les plus adaptéesI Utiliser atomic ou reduction plutôt que critical

I Équilibrer la charge entre les threadsI Utiliser les possibilités de la clause schedule

I Donner suffisamment de travail aux threadsI Penser à la clause if

C 90

Documents

OpenMP - unistra.fricps.u-strasbg.fr/~bastoul/teaching/openmp/bastoul_cours_openmp.pdf · I 1997OpenMP 1.0 pour Fortran, C/C++ en 1998 I 2000OpenMP 2.0 parallélisation de constructions