Groupe calcul parallèle

Transcription

1 Groupe calcul parallèle «Exploiter le potentiel des nouvelles architectures» Vincent Lafage Luz Guevara Ivana Hrivnacova Christophe Diarra Contact :Luz Guevara 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 1 D2I, Institut de Physique Nucléaire Université d Orsay 20 décembre / 12

4 Pourquoi paralléliser? Loi de Moore depuis 1971 : le nombre de transistors sur un circuit intégré double tous les deux ans µm, nm + 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 1993) / 12

5 Pourquoi paralléliser?... doublement de la fréquence tous les 2 ans, 2 ans et demi? Vrai depuis 1980 Plus depuis 2004!!! Pentium 4 : 3 GHz on attend entre 16 et 32 fois plus, > 50 GHz!!! P = C.V 2.f W 2,5 kw!!! Trop d énergie à dissiper! plusieurs processeurs sur un même circuit : plusieurs cœurs / 12

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! / 12

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

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) / 12

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

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

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 COMMON n est pas commun / 12

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

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 : / 12

14 Merci de votre attention questions? : / 12

15 Programmation sequentielle et parallèle 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 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 sousproblèmes qui peuvent être traités de façon concurrente instructions exécutées les unes après les autres une seule instruction à la fois chaque sous-problème ou ensemble des insructions est executé sur une unité de calcul.

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 sousprogramme 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 Message-Passing Interface 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)

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; }

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 MPI_COMM_WORLD 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)

23 #include <stdio.h> #include <stdlib.h> #include <mpi.h> #include <math.h> Communications point à point /************************************************************ This is is a simple send/receive program in 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; 0; } 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.

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: Geant 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 Geant Version 10.0 was released on December 6th, The first major release since June 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 Séminaire sur le calcul parallèle et GPU,20 December 2013, IPN Orsay 2

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 Séminaire sur le calcul parallèle et GPU,20 December 2013, IPN Orsay 3

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 hitscollection Shares read-only data structures (e.g. geometry, crosssections,?) Geant4 automatically performs reductions (accumulation) when using scorers, G4Run derived classes or g4tools Séminaire sur le calcul parallèle et GPU,20 December 2013, IPN Orsay 4

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 Séminaire sur le calcul parallèle et GPU,20 December 2013, IPN Orsay 5

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 Séminaire sur le calcul parallèle et GPU,20 December 2013, IPN Orsay 6

33 Results (3) Intel Xeon Phi TM 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 Séminaire sur le calcul parallèle et GPU,20 December 2013, IPN Orsay 7

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 Séminaire sur le calcul parallèle et GPU,20 December 2013, IPN Orsay 8

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 Expression of interest by some LHC experiment A preliminary version of one example is provided in Geant4 examples/extended/parallel/tbb Séminaire sur le calcul parallèle et GPU,20 December 2013, IPN Orsay 9

36 Documentation Geant4 Web site: 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 Séminaire sur le calcul parallèle et GPU,20 December 2013, IPN Orsay 10

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 Séminaire sur le calcul parallèle et GPU,20 December 2013, IPN Orsay 2

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,... Séminaire sur le calcul parallèle et GPU,20 December 2013, IPN Orsay 5

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: Root documentation: Séminaire sur le calcul parallèle et GPU,20 December 2013, IPN Orsay 7

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

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 2

46 : 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) 3

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) 4

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 5

49 Authentification Autorisation Accounting Workload Management System (WMS) Information sur le CE, SE Information System Données d auth. & d autorisation User Interface Computing Element Soumission job + suivi et récupération résultat Soumission job et récupération résultat Demande status Logging & Bookeeping (LB) Information sur la localisation des données Informations publiées par les services CE, SE, Worker Nodes Storage Element File Replica Metadata Catalog

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

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

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

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 2

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 3

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

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 ) 6

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 7

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) 8

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); } 9

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 10

63 Pour pouvoir utiliser la biblothèque OpenMP: Fortran INTEGER FUNCTION OMP_GET_NUM_THREADS() ou USE OMP_LIB NBTHREADS = OMP_GET_NUM_THREADS() C/C++ #include <omp.h> nbthreads=omp_get_num_threads(); 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 11

64