Groupe calcul parallèle

Texte intégral

(1)

Groupe calcul parallèle

« Exploiter le potentiel des nouvelles architectures »

Vincent Lafage Luz Guevara Ivana Hrivnacova Christophe Diarra

Contact :Luz Guevara e-mail : guevara@ipno.in2p3.fr

Tel : 54463

(2)

Plan

Nouvelles architectures des ordinateurs et la nécessité de paralléliser.

Calcul par GPU

Les concepts de base de la programmation parallèle

Programmation avec MPI

La parallélisation dans ROOT et Geant4

Les ressources informatiques disponibles au laboratoire et leur utilisation

Programmation avec openMP

(3)

Groupe Parallèle du S2I

ou pourquoi paralléliser ?

Vincent C.Lafage

1D2I, Institut de Physique Nucléaire Université d’Orsay

20 décembre 2013

(4)

Pourquoi paralléliser ?

Loi de Mooredepuis: le nombre de transistors sur un circuit intégré double tous les deux ans

10µm,22nm

+ de registres + de mémoire cache + d’instructions processeurs

+ de taille de bus (de 4 bits à 64 bits) + de gestion de la mémoire (MMU)

+ d’unités de calcul (un, plusieurs FPU, ALU vectorielle…) + d’étages de pipeline (superscalaires cf Pentium ca)

(5)

Pourquoi paralléliser ?

. . . doublement de la fréquence tous les 2 ans, 2 ans et demi ? Vrai depuis

Plus depuis!!! Pentium 4 : 3 GHz…

on attend entre 16 et 32 fois plus, > 50 GHz !!!

P =C.V2.f

70–85 W 2,5 kW !!!

Trop d’énergie à dissiper !

plusieurs processeurs sur un même circuit : plusieurs cœurs

(6)

Pourquoi paralléliser ?

pour continuer à bénéficier de la puissance croissance de la technologie, pas d’autre solutions que la programmation parallèle :coordonner le travail des différents cœurs

alors qu’on nous a toujours enseigné l’aspect essentiellement séquentiel de la programmation !

(7)

Pourquoi paralléliser ?

les nouvelles technologies consomment une part croissante d’une énergie rare & chère.

1,6 Megawatts informatiques dans la première salle du Centre de Calcul de l’IN2P3 : 0,5 à 1 M€

évolution vers un meilleur ratio W/MIPS ou W/MFLOPS : Intel XScale, 600 MHz, 0,5 W

5 fois plus lent, 80 fois plus économe !

diminuer la fréquence, vu qu’il y aura plus de coeurs

(8)

Comment paralléliser ?

c’est un paradigme de programmation complémentaire des approches classiques : procédural, modulaire, générique, objet.

… et qui s’appuie sur différentes technologies matérielles également

pipeline (DSP)

vectorisation (SIMD)

parallèlisation par processus (lourds) assez indépendants

parallèlisation par processus légers (threads= fils) partageant l’espace d’un même processus :économie de mémoire

distribution (parallèlisation par processus tournant sur des machines différentes)

(9)

GPU :Graphics Processing Unit

rendu 3D, gestion de mémoire vidéo, traitement du signal vidéo, filtrage, décompression Mpeg

cœurs de CPU : très (trop ?) complexe, gourmand 2 nJ/FLOP

GPU : dédié 200 pJ/FLOP

centaines de cœurs : Multicore Many-cores

CUDA PGI Fortran OpenCL

(10)

exemple : MonteCarlo

une grande boucle

..

1 on choisit un point au hasard dans l’espace des configuration

..

2 on calcule certaines grandeurs associées à cette configuration

sa section efficace différentielle :

sa probabilité d’apparition|M|2

le poids de cette configuration dans l’espace des phase invariant de Lorentz

les énergies & les angles d’émergence des particules sortantes dans le référentiel du laboratoire et du CM

..

3 si la configuration répond aux contraintes d’observation expérimentales (« coupures ») on la garde, sinon on la jette. Si on la garde, on doit empiler sa contribution dans différentes variables : section efficace totale

(11)

exemple : MonteCarlo

simple ?

A goulet (bottleneck) au point 3

B goulet au point 1 : le générateur pseudo-aléatoire de base est avant tout séquentiel, et plusieurs instances doivent être sur des séquences bien distinctes pour que la Méthode de Monte-Carlo soit utile.

C point 2 ? pas innocent. . . expliquer aux différents threads que le COMMONn’est pas commun.

(12)

exemple : MonteCarlo

découper la grande boucle avant de la distribuer :

tour de boucle à 20 µs / événement pas rentable ! + tour de boucle à 200 ms / 10 k.événement

(13)

Conclusion

+ beaucoup de perspectives

pour les anciens codes. . .

. . .et pour les nouveaux

+ beaucoup de solutions

pas si évident

demandez-nous conseil

! d’abord, optimiser

lafage@ipno.in2p3.fr :

(14)

Merci de votre attention

questions ?

lafage@ipno.in2p3.fr :

(15)

Programmation sequentielle et parallèle

La programmation parallèle implique l’exécution de plusieurs instructions simultanément:

plusieurs processeurs exécutent les instructions

le problème est découpé en plusieurs sous- problèmes qui peuvent être traités de façon concurrente

chaque sous-problème ou ensemble des insructions est executé sur une unité de calcul.

La programmation sequentielle est le paradigme de programmation

traditionellement utilisé.

Un problème est decomposé en une sequence d'operations :

un seul processeur central (CPU) exécute les instructions

instructions exécutées les unes après les autres

une seule instruction à la fois

(16)

Modèles de programmation parallèle

Il existe plusieurs modèles de programmation parallèle d'usage courant:

Mémoire partagée

Threads

Passage de message

Données parallèles

Hybride

Modèles de programmation parallèles existent comme une

abstraction au-dessus des architectures matérielles et de la mémoire.

(17)

Modèle Threads

Un thread peut être considéré comme un sous- programme dans le programme principal

Le programme principal acquiert les ressources

nécessaires à l'exécution du programme et après un peu de travail sequentiel il va créer un certain nombre de threads qui peuvent être planifiées et gérées par le système d'exploitation de façon concurrente.

Les threads communiquent les uns avec les autres à travers la mémoire globale. Cela nécessite des constructions de synchronisation

Chaque thread dispose des données locales et aussi partage l'ensemble des réssources du programme principal

Souvent associé aux architectures à mémoire partagé et les systèmes d'exploitation

Threads POSIX ou pthreads

OpenMP → Christophe

Gean 4, ROOT → Ivanna

(18)

Modèle par passage de message

Le programme est dupliqué sur plusieurs processus

Chaque processus exécute

éventuellement des parties différentes du même programme.

Toutes les variables du programme sont privées et résident dans la

mémoire locale allouée à chaque processus

Les tâches échangent des données grâce à des communications en

envoyant et recevant des messages.

Souvent associé aux architectures à mémoire distribuée.

MPI : OpenMPI, MPICH

(19)

Interface de passage de messages

MPI est une spécification pour les développeurs et les utilisateurs des bibliothèques de passage de message. Utilisable depuis C, C++, Fortran77/90/95.

Définit un ensemble d'appels standard de la bibliothèque.

La communication des données par passage de message :

Permet le travail en commun des processus pour résoudre un problème

Les données sont décomposés (split) en plusieurs parties

Chaque processus gère une partie séparée sur son propre processeur

MPI permet de gérer :

l ’environnement d ’exécution

les communications point à point (Send, Recv)

les communications collectives (Bcast, Scatter, Gather,…)

les groupes de processus et des communicateurs

la topologie d’inter-connexion des processus (grilles, tore, arbre,…=> notion de voisinage)

Message-Passing Interface

(20)

Principe d’un programme MPI

On écrit un programme contenant les

opérations locales + les échanges via MPI (initialisation et échanges).

On compile avec mpicc monprog.c -o monprog

On lance par mpirun –machinefile filename -np n monprog

n=nombre de processus

La liste des machines peut être définie explicitement

MPI crée n copies de l’exécutable sur les machines cibles

Exécution asynchrone des processus (+synchro sur échange messages)

Terminaison des processus

(21)

Environnement système

Pour utiliser MPI :

Appel au module MPI :

« include mpif.h » en fortran77.

« use MPI » fortran90

« include mpi.h » en C/C++.

L'initialisation de l'environnement via MPI_Init crée le communicateur par default MPI_COMM_WORLD.

Environnement initialise = processus actifs + espace de communication

La désactivation de l'environement via l'appele a la subroutine

MPI_FINALIZE

MPI_Init et MPI_Finalize sont des fonction collectives! (appelée par tous les processus)

#include <stdlib.h>

#include <mpi.h>

#include <math.h>

/************************************************************

This is a simple send/receive program in MPI

************************************************************/

int main(int argc, char *argv[]) {

int myid, numprocs;

int tag,source,destination,count;

int buffer;

MPI_Status status;

MPI_Init(&argc,&argv);

MPI_Comm_size(MPI_COMM_WORLD,&numprocs);

MPI_Comm_rank((MPI_COMM_WORLD,&myid);

…...

MPI_Finalize();

return 0;

}

#include <stdlib.h>

#include <mpi.h>

#include <math.h>

/************************************************************

This is a simple send/receive program in MPI

************************************************************/

int main(int argc, char *argv[]) {

int myid, numprocs;

int tag,source,destination,count;

int buffer;

MPI_Status status;

MPI_Init(&argc,&argv);

MPI_Comm_size(MPI_COMM_WORLD,&numprocs);

MPI_Comm_rank(MPI_COMM_WORLD,&myid);( …...

MPI_Finalize();

return 0;

}

(22)

Communications point à point

Une communication dite point à point a lieu entre deux

processus, qui par l'intermédiaire des messages, s'envoie des données.

Structure d'un message MPI

En plus des données, le message contient une ''enveloppe'' qui est constitué de plusieurs champs:

Source: rang du processus qui envoie.

Destination: rang du processus qui reçoit

Etiquette: entier qui identifie le message de manière unique.

Communicateur: communicateur au sein duquel se fait l'échange.

Les données échangées sont typées (entiers, réels, types dérivés personnels)

00 11 22 33

MPI_COMM_WORLD

(23)

#include <stdio.h>

#include <stdlib.h>

#include <mpi.h>

#include <math.h>

/************************************************************

This is a simple send/receive program in MPI

************************************************************/

int main(int argc, char *argv[]) {

int myid, numprocs;

int etiquette,source,destination,longueur;

int message;

MPI_Status status;

MPI_Init(&argc,&argv);

MPI_Comm_size(MPI_COMM_WORLD,&numprocs);

MPI_Comm_rank(MPI_COMM_WORLD,&myid);

etiquette=1234;

source=0;

destination=1;

longueur=1;

if(myid == source){

message=5678;

MPI_Send(&message,longueur,MPI_INT,destination,etiquette,MPI_COMM_WORLD);

printf("processor %d sent %d\n",myid,message);

}

if(myid == destination){

MPI_Recv(&message,longueur,MPI_INT,source,etiquette,MPI_COMM_WORLD,&status);

printf("processor %d got %d\n",myid,message);

}

MPI_Finalize();

return 0;

#include <stdio.h>

#include <stdlib.h>

#include <mpi.h>

#include <math.h>

/************************************************************

This is a simple send/receive program in MPI

************************************************************/

int main(int argc, char *argv[]) {

int myid, numprocs;

int etiquette,source,destination,longueur;

int message;

MPI_Status status;

MPI_Init(&argc,&argv);

MPI_Comm_size(MPI_COMM_WORLD,&numprocs);

MPI_Comm_rank(MPI_COMM_WORLD,&myid);

etiquette=1234;

source=0;

destination=1;

longueur=1;

if(myid == source){

message=5678;

MPI_Send(&message,longueur,MPI_INT,destination,etiquette,MPI_COMM_WORLD);

printf("processor %d sent %d\n",myid,message);

}

if(myid == destination){

MPI_Recv(&message,longueur,MPI_INT,source,etiquette,MPI_COMM_WORLD,&status);

printf("processor %d got %d\n",myid,message);

}

MPI_Finalize();

return 0;

}

Communications point à point

MPI_SEND

(message,longueur,type,rang_dest,etique tte,comm)

MPI_RECV

(message,longueur,type,rang_source,etiq uette,comm,statut)

(24)

Communications collectives

Les communication collectives permettent de communiquer en un seul appel avec tous les processus d’un communicateur.

Il y a trois types de communications colectives:

Synchronisations globales (MPI_Barrier)

Tranferts/échanges de données

Diffusion de données (globales avec MPI_Bcast, sélectives avec

MPI_Scatter)

Collecte de données (MPI_Gather et MPI_Allgather)

Echanges globaux (MPI_Alltoall)

Opérations de réduction

MPI_Reduce : Permet de faire des opérations de réduction sur des

données réparties entre les processus d'un communicateur.

– Collective computation

(25)

Quand utiliser MPI ?

On souhaite un programme parallèle portable

Quand il s'agit de faire une grande quantité de calcul et peu de communication entre les processus.

Attention !!

MPI necessite d'avantage des changements pour passer de la

version sequentielle à la version parallèle du code. Il est preferable de l'utiliser depuis le début du codage du programme.

Peut être plus difficile à déboguer.

Le performance d'une application peut être limité par le réseau de communication entre les noeuds

(26)

Merci pour vottre attention!

Questions?

(27)

Parallelism in Geant4:

Geant4 10.00

I. Hrivnacova, IPN Orsay

Based on material presented at

Geant4 Technical Forum, 10 December 2013, CERN, by Makoto Asai, Andrea Dotti, SLAC

and at

CHEP 2013, by Gabriele Cosmo, CERN

Séminaire sur le calcul parallèle et GPU, 20 December 2013, IPN Orsay

(28)

Geant4 10.00

Version 10.0 was released on December 6th, 2013.

The first major release since June 2007.

There are several highlighted features including

Multi-threading capability with event parallelism

It offers two build options: Multi-threaded and Sequential mode

Selection via a cmake configuration option -DGEANT4_BUILD_MULTITHREADED=ON

Consolidation of multiple-scattering, Isomer production, Enhancements in biasing options, ...

Not subject of this presentation

(29)

Geant4 MT

Event level parallelism via multi-threading (POSIX based)

Built on top of experience of G4MT prototypes

Capitalizing the work started back in 2009 by X.Dong and G.Cooperman, Northeastern University

Main design driving goal: minimize user-code changes

Integrated into Version 10.0 codebase

(30)

Event-Level Parallelism

Each worker thread proceeds independently

Initializes its state from a master thread

Identifies its part of the work (events)

Generates hits in its own hits- collection

Shares read-only data

structures (e.g. geometry, cross- sections, ?)

Geant4 automatically performs reductions (accumulation) when using scorers, G4Run derived classes or g4tools

(31)

Results (1)

Showing good efficiency w.r.t. excellent linearity vs. number of threads (~95%)

Up to very large number of threads O(100)

From 1.1 to 1.5 extra gain factor in HT-mode on HT-capable hardware

(32)

Results (2)

MT functionality introduce minimal overhead in single thread

1thread: CPU penalty ~1%

Good memory reduction

10 threads: 50% memory w.r.t 10 instances

Based on performance analysis on full-CMS benchmark

(33)

Results (3)

Intel® Xeon PhiTM coprocessor

Using out-of-the-box 10.0-beta (i.e. no optimisations)

~40 MB/thread

Baseline: Full-CMS benchmark; 200 MB (geometry and physics)

Speedup almost linear with reasonably small increase of memory usage

(34)

Results (4)

Fully reproducible: given an event and its initial seed the

random number generator history is independent of the number of threads and order in which these are simulated

Corollary: given the seeds, sequential and MT builds are equivalent

Many physics validation plots

Comparison of physics results in MT-mode vs. sequential

(35)

Heterogeneous Parallelism

MPI

MPI works together with MT

The examples of MPI parallelism with Geant4 MT are provided in Geant4 examples/extended/parallel/MPI

TBB

Intel Thread Building Block (TBB): task based parallelism framework

https://www.threadingbuildingblocks.org/

Expression of interest by some LHC experiment

A preliminary version of one example is provided in Geant4 examples/extended/parallel/TBB

(36)

Documentation

Geant4 Web site:

http://geant4.web.cern.ch/geant4/

Application Developer’s guide and Toolkit Developer’s guide have been updated

All basic and many extended and advanced examples were migrated to MT

Twiki

How to migrate user-code to multi-threading

https://twiki.cern.ch/twiki/bin/view/Geant4/MultiThreadingTaskForce

(37)

Parallelism in ROOT:

PROOF

I. Hrivnacova, IPN Orsay

Séminaire sur le calcul parallèle et GPU, 20 December 2013, IPN Orsay

(38)

PROOF

PROOF = The Parallel ROOT Facility

An extension of ROOT enabling interactive analysis of large sets of ROOT files in parallel on clusters of computers or many-core machines.

More generally PROOF can parallelize tasks that can be formulated as a set of independent sub-tasks

PROOF for TSelector based analysis:

Start analysis locally ("client"),

PROOF distributes data and code,

Lets CPUs ("workers") run the analysis,

Collects and combines (merges) data,

Shows analysis results locally

(39)

Séminaire sur le calcul parallèle et GPU,20 December 2013, IPN Orsay 3

With courtesy of Bertrand Bellenot, Axel Naumann, CERN

(40)

Séminaire sur le calcul parallèle et GPU,20 December 2013, IPN Orsay 4

With courtesy of Bertrand Bellenot, Axel Naumann, CERN

(41)

TSelector & PROOF

To be able to perform event-level parallelism, PROOF needs to be in charge of the event-loop;

This is provided by the Selector framework, defined by the abstract class TSelector with methods

Begin() - called on the client only

SlaveBegin() - called on each worker (create histograms)

Process() - do event analysis

SlaveTerminate() - rarely used; post processing of partial results before they are sent to master and merged

Terminate() - runs on the client: save results, display histograms, ...

(42)

Séminaire sur le calcul parallèle et GPU,20 December 2013, IPN Orsay 6

With courtesy of Bertrand Bellenot, Axel Naumann, CERN

(43)

Documentation

“Formation ROOT” in February 2012 at IPN Orsay:

http://ipnwiki.in2p3.fr/ipnsii/index.php/Formation_ROOT_2012

Root documentation:

http://root.cern.ch/drupal/content/proof

(44)

Christophe DIARRA Séminaire sur le calcul parallèle et GPU IPNO - 20/12/2013 diarra@ipno.in2p3.fr

(45)

C’est un ensemble de ressources

informatiques distribuées géographiquement , reliées à Internet et interagissant via un middleware (intergiciel)

Les ressources sont : les CPU, le stockage, les logiciels

Le matériel informatique est hétérogène et géré de façon décentralisée

Grace au middleware les utilisateurs disposent d’un supercalculateur virtuel

La grille facilite la mutualisation des

ressources et la collaboration scientifique

(46)

2001-2010 : projets européens sur les grilles

European DataGrid (EDG)

Enabling Grids for E-SciencE (EGEE)

Buts : Créer une grille européenne pour la communauté scientifique

Avril 2010 : fin EGEE début EGI

S’appuie sur les NGI (National Grid Initiative)

En France la NGI (GIS France Grilles) est pilotée par l’Institut des Grilles et du Cloud du CNRS

Buts : pérenniser l’infrastructure de grille en Europe

EGI comporte 37 NGI + CERN

EGI fournit le middleware EMI (european middleware initiative)

LCG est la plus grande grille de production au monde (300K CPU, 200 PB disk et 100PB tape, +1M jobs/jour)

(47)

Le middleware EMI comprend :

Un système d’autorisation et d’authentification

Un système de gestion de jobs

Un système de gestion des données

Un système d’information

Un système d’accounting (comptabilité)

Un système de monitoring (supervision)

(48)

Il faut posséder un certificat électronique

S’inscrire dans une Organisation Virtuelle

Une VO (Virtual Organization) est une

communauté d’utilisateurs ayant des intérêts communs et qui utilisent la grille pour

collaborer et partager des ressources

Se servir des utilitaires ou outils (fournis) pour transférer des données

Soumettre un job (traitement par lot) pour pour faire tourner un code de calcul

(49)

6 Authentification

Autorisation Accounting Workload Management

System (WMS) Information System

User Interface

Worker Nodes Computing

Element

Soumission job + suivi et

récupération résultat

Logging &

Bookeeping (LB)

Demande status

Information sur le CE, SE

Storage Element

File Replica Metadata Catalog

Information sur la localisation des

données Informations publiées par les services CE, SE,

Soumission job et récupération résultat

Données d’auth.

& d’autorisation

(50)

La grille avec 2 clusters distincts:

CE ipngrid04: >800 cores

CE ipngrid12: 496 cores avec MPI/IB

2 SE : DPM (17 TB), xrootd (>300 TB pour ALICE)

2 UI: ipngrid01 et ipngrid02

Calcul interactif : sur ipngrid01 (32 cores) + 3GPUs NVIDIA M2090

Compilateurs/Logiciels: CUDA, Compilateurs

Intel/MKL, PGI/ACML, Matlab, Mathematica, NAG

~30 utilisateurs locaux (RC, PACS/MURE, PANDA, Physique Théorique, AUGER, Instrumentation, …)

NB: ressources GRIF disponibles aussi (12K cores, 4PB)

(51)

JDL :

$ cat hello.jdl

Executable = "/bin/echo";

Arguments = "Hello World";

StdOutput = "std.out";

StdError = "std.err";

OutputSandbox = {"std.out","std.err"};

Requirements = RegExp("ipngrid04.in2p3.fr.*ipno$",other.GlueCEUniqueID);

voms-proxy-init --voms vo.ipno.in2p3.fr --valid 24:0

glite-wms-job-submit -a -o jid hello.jdl

glite-wms-job-status -i jid

glite-wms-job-output -i jid

8

(52)

https://ipngridwiki.in2p3.fr

http://www.egi.eu

http://lcg.web.cern.ch/lcg/

http://public.web.cern.ch/public/

http://grif.fr

http://www.gridcafe.org/index.html

(53)

Christophe DIARRA Séminaire sur le calcul parallèle et GPU

IPNO - 20/12/2013 diarra@ipno.in2p3.fr

(54)

C’est un standard industriel qui permet de la la parallélisation multi-tâches/multi-threads dans un contexte de mémoire partagée

OpenMP propose une API pour C/C++, Fortran avec:

Des directives du compilateurs

Des bibliothèques

Des variables d’environnement

Le parallélisme est explicite mais la communication inter-tâches est gérée par le compilateur

OpenMP ne sait :

Gérer la mémoire distribuée

Gérer les I/O parallèles dans un même fichier (pas de garantie du résultat)

Détecter les problèmes de dépendances des données, d’accès concurrents, de deadlocks, de conflits entre données

(55)

Peu de directives au total

Possibilité de paralléliser avec 3 ou 4 directives

Facilité d’utilisation:

parallélisation incrémentale à la différence de MPI

Même* code source pour la version parallèle et série

(*) Moyenanant quelques directives du préprocesseur

(56)

Un programme OpenMP est exécuté par un processus unique qui active des threads à l’entrée d’une région parallèle

OpenMP utilise le modèle Fork – Join

4

(57)

Forme générale:

sentinelle directive [clause, ...]

Exemples:

Fortran: !$OMP PARALLEL DEFAULT(SHARED) PRIVATE(BETA,PI)

C/C++: #pragma omp parallel default(shared) private(beta,pi)

N.B.: sentinelles acceptés en Fortran

en free form source fortran: !$OMP

en fixed form source fortran: !$OMP, C$OMP,

*$OMP en colonne 1

Lors d’une compilation sans OpenMP, les

lignes de directives sont traitées comme des lignes de commentaires.

(58)

En Fortran:

!$OMP directive

[ structured block of code ]

!$OMP end directive

En C/C++:

#pragma directive

[ structured block of code ]

NB: En C le bloc est délimité par ‘{}’ sauf s’il est implicite (ex: après un ‘#pragma omp for’)

(59)

Une région parallèlle est un bloc de code exécuté par plusieurs threads

Fortran !$OMP PARALLEL [clause ...]

IF (scalar_logical_expression) PRIVATE (list)

SHARED (list)

DEFAULT (PRIVATE | FIRSTPRIVATE | SHARED | NONE) FIRSTPRIVATE (list)

REDUCTION (operator: list) COPYIN (list)

NUM_THREADS (scalar-integer-expression) block

!$OMP END PARALLEL

C/C++ #pragma omp parallel [clause ...] newline if (scalar_expression)

private (list) shared (list)

default (shared | none) firstprivate (list)

reduction (operator: list) copyin (list)

num_threads (integer-expression) structured_block

(60)

Parallélisation de boucles (DO/for)

Création de sections (pour les blocs de code indépendants) : SECTIONS

Exécution : exécution mono-thread (SINGLE)

(61)

PROGRAM DOT_PRODUCT

INTEGER N, CHUNKSIZE, CHUNK, I PARAMETER (N=100)

PARAMETER (CHUNKSIZE=10) REAL A(N), B(N), RESULT

! Some initializations DO I = 1, N

A(I) = I * 1.0 B(I) = I * 2.0 ENDDO

RESULT= 0.0

CHUNK = CHUNKSIZE

!$OMP PARALLEL DO

!$OMP& DEFAULT(SHARED) PRIVATE(I)

!$OMP& SCHEDULE(STATIC,CHUNK)

!$OMP& REDUCTION(+:RESULT) DO I = 1, N

RESULT = RESULT + (A(I) * B(I)) ENDDO

!$OMP END PARALLEL DO

PRINT *, 'Final Result= ', RESULT END

#include <omp.h>

main () {

int i, n, chunk;

float a[100], b[100], result;

/* Some initializations */

n = 100;

chunk = 10;

result = 0.0;

for (i=0; i < n; i++) {

a[i] = i * 1.0;

b[i] = i * 2.0;

}

#pragma omp parallel for \ default(shared) private(i) \ schedule(static,chunk) \ reduction(+:result)

for (i=0; i < n; i++)

result = result + (a[i] * b[i]);

printf("Final result= %f\n",result);

}

(62)

BARRIER: synchronise tous les threads du groupe

MASTER: restreint l’exécution d’un bloc de code au master thread. Les autres thread continuent leur exécution après cette

section. Donc synchroniser si nécessaire avec BARRIER.

CRITICAL: un seul thread peut s’exécuter à la fois

ATOMIC: lecture+modification+écriture atomique

(63)

Pour pouvoir utiliser la biblothèque OpenMP:

Compilation GNU:

gcc –fopenmp –o prog prog.c

gfortran –fopenmp –o prog prog.f

Compilation Intel:

icc –openmp –o prog prog.c

ifort –openmp –o prog prog.f

setenv OMP_NUM_THREADS 8

./prog

Fortran C/C++

INTEGER FUNCTION OMP_GET_NUM_THREADS() ou

USE OMP_LIB

NBTHREADS = OMP_GET_NUM_THREADS()

#include <omp.h>

nbthreads=omp_get_num_threads();

(64)

https://computing.llnl.gov/tutorials/openMP

https://computing.llnl.gov/tutorials/openMP/exercise.html

http://www.idris.fr/data/cours/parallel/openmp

Figure

Updating...

Sujets connexes :
Outline : PROOF