Téléchargé parangelo119154
18 vues

Introduction à la programmation parallèle avec OpenMP

OpenMP est une API pour la programmation parallèle en mémoire partagée, supportant des langages comme C, C++, et Fortran. Elle utilise des directives et des fonctions pour paralléliser le code, facilitant son utilisation par des non spécialistes, mais ne permet pas de créer des outils de synchronisation personnalisés. Le document présente également des exemples de code et des techniques pour optimiser le parallélisme efficace.

Intégrer la présentation

Télécharger pour lire hors ligne
OpenMP   www.openmp.org   • Une  API  pour  la  programma4on  parallèle  en  mémoire  partagée   – C,  C++,  Fortran   – Portable   – Porté  par  l’Architecture  Review  Board  (Intel,  IBM,  AMD,  MicrosoD,   Cray,  Oracle,  NEC…)   • Basé  sur  des  annota4ons  :  #pragma  omp  direc1ve   • et  des  fonc4ons:  omp_fonc1on()   • Permet  de  paralléliser  un  code  de  façon  plus  ou  moins  intrusive  un   code   – Plus  on  en  dit  plus  on  a  de  performance   – Facile  à  meRre  en  œuvre  par  un  non  spécialiste…  Trop  facile  ?   • Ne  permet  pas  de  créer  ses  propres  ou4l  de  synchronisa4on   • hRps://compu4ng.llnl.gov/tutorials/openMP/  
Hello  world  !     int  main()   {      prin[("bonjourn");      prin[("au  revoirn")  ;          return  EXIT_SUCCESS;   }           >  gcc  bon.c   >./a.out   bonjour       au  revoir   >  
Hello  world  !   #include  <omp.h>     int  main()   {   #pragma  omp  parallel      prin[("bonjourn");        prin[("au  revoirn")  ;          return  EXIT_SUCCESS;   }     >  gcc  –fopenmp  bon.c   >./a.out   bonjour       bonjour     bonjour     bonjour     au  revoir   >      
Hello  world  !   #include  <omp.h>     int  main()   {   #pragma  omp  parallel      prin[("bonjourn");        prin[("au  revoirn")  ;          return  EXIT_SUCCESS;   }       >  gcc  –fopenmp  bon.c   >OPENMP_NUMTHREADS=3  ./a.out   bonjour       bonjour     bonjour     au  revoir   >      
Hello  world  !   #include  <omp.h>     int  main()   {   #pragma  omp  parallel      prin[("bonjourn");        prin[("au  revoirn")  ;          return  EXIT_SUCCESS;   }   >  export  OPENMP_NUMTHREADS=3     >  gcc  –fopenmp  bon.c   >./a.out   bonjour       bonjour     bonjour     au  revoir   >      
Hello  world  !   #include  <omp.h>   int  main()   {   #pragma  omp  parallel  num_threads(3)      prin[("bonjourn");        prin[("au  revoirn")  ;      return  EXIT_SUCCESS;   }     >  gcc  –fopenmp  bon.c   >./a.out   bonjour       bonjour     bonjour     au  revoir   >      
Hello  world  !   #include  <omp.h>   int  main()   {   omp_set_num_threads(3);   #pragma  omp  parallel      prin[("bonjourn");        prin[("au  revoirn")  ;      return  EXIT_SUCCESS;   }   >  gcc  –fopenmp  bon.c   >./a.out   bonjour       bonjour     bonjour     au  revoir   >      
Parallélisme  fork-­‐join   • Un  unique  thread  exécute  séquen4ellement   le  code  de  main.     • Lors  de  la  rencontre  d’un  bloc  parallèle,  tout   thread     – crée  une  équipe  de  threads     – la  charge  d'exécuter  une  fonc4on   correspondant  au  bloc  parallèle     – rejoint  en  tant  que  maître  l’équipe.     • À  la  fin  du  bloc  parallèle     – les  threads  d’une  même  équipe  s'aRendent   au  moyen  d'une  barrière  implicite       – les  threads  esclaves  sont  démobilisés   – le  thread  maître  retrouve  son  équipe   précédente     #pragma  omp  parallel   Barrière   0   1   2  
Hello  world  !   #include  <omp.h>   int  main()   {   #pragma  omp  parallel      {    prin[("bonjourn");      //  barrière  implicite      }   prin[("au  revoirn")  ;      return  EXIT_SUCCESS;   }        
Traduc4on  en  pthread   #pragma  omp  parallel   f();               {   pthread_t  4d[K];   for(int  i=1;i<k;i++)    pthread_create(4d+i,0,f,i);   f(0);     for(int  i=1;i<k;i++)    pthread_join(4d[i]);   }      
Calcul  en  parallèle  de  Y[i]  =  f(T,i)     Pthread   #define  NB_ELEM  (TAILLE_TRANCHE  *   NB_THREADS)   pthread_t  threads[NB_THREADS];   double  input[NB_ELEM],  output[NB_ELEM];       void  appliquer_f(void  *i)     {      int  debut  =  (int)  i  *  TAILLE_TRANCHE;    int  fin  =  ((int)  i+1)  *  TAILLE_TRANCHE;        for(  int  n=  debut;  n  <  fin;  n++)      output[n]  =  f(input,n);       //    pthread_exit(NULL);   }       int  main()   {   …      for  (int  i  =  0;  i    <  NB_THREADS;  i++)        pthread_create(&threads[I],  NULL,                                                                                appliquer_f,  (void  *)i);        for  (int  i  =  0;  i    <  NB_THREADS;  i++)        pthread_join(threads[I],  NULL);        ...   }   Parallélisa4on  efficace  si  équilibrée  
Calcul  en  parallèle  de  Y[i]  =  f(T,i)     OpenMP   #define  NB_ELEM  (TAILLE_TRANCHE  *   NB_THREADS)   pthread_t  threads[NB_THREADS];   double  input[NB_ELEM],  output[NB_ELEM];       void  appliquer_f(void  *i)     {      int  debut  =  (int)  i  *  TAILLE_TRANCHE;    int  fin  =  ((int)  i+1)  *  TAILLE_TRANCHE;        for(  int  n=  debut;  n  <  fin;  n++)      output[n]  =  f(input,n);       //    pthread_exit(NULL);   }       int  main()   {   …    #pragma  omp  parallel                    appliquer_f,  (omp_get_thread_num());      ...   }  
Calcul  en  parallèle  de  Y[i]  =  f(T,i)     distribu4on  d’indices   #define  NB_ELEM  (TAILLE_TRANCHE  *   NB_THREADS)   pthread_t  threads[NB_THREADS];   double  input[NB_ELEM],  output[NB_ELEM];       /*  void  appliquer_f(void  *i)     {      int  debut  =  (int)  i  *  TAILLE_TRANCHE;    int  fin  =  ((int)  i+1)  *  TAILLE_TRANCHE;        for(  int  n=  debut;  n  <  fin;  n++)      output[n]  =  f(input,n);       //    pthread_exit(NULL);   }  */     int  main()   {   …    #pragma  omp  parallel                #pragma  omp  for   for(  int  n=  debut;  n  <  fin;  n++)      output[n]  =  f(input,n);      ...   }  
Calculer  Y[i]  =  f^k(T,i)    pthread     #define  NB_ELEM  (TAILLE_TRANCHE  *   NB_THREADS)   pthread_t  threads[NB_THREADS];   double  input[NB_ELEM],  output[NB_ELEM];       void  appliquer_f(void  *i)     {      int  debut  =  (int)  i  *  TAILLE_TRANCHE;    int  fin  =  ((int)  i+1)  *  TAILLE_TRANCHE;        for(  int  n=  debut;  n  <  fin;  n++)      output[n]  =  f(input,n);       //    pthread_exit(NULL);   }       int  main()   {   …   for  (int  etape  =  0;  etape  <  k;  etape++)   {      for  (int  i  =  0;  i    <  NB_THREADS;  i++)        pthread_create(&threads[I],  NULL,                                                                                appliquer_f,  (void  *)i);        for  (int  i  =  0;  i    <  NB_THREADS;  i++)        pthread_join(threads[I],  NULL);       memcpy(input,output,…);   }    ...   }  
Calculer  Y[i]  =  f^k(T,i)     OpenMP   int  main()   {   …   for  (int  etape  =  0;  etape  <  k;  etape++)   {   #pragma  omp  parallel  for   for(  int  n=  debut;  n  <  fin;  n++)      output[n]  =  f(input,n);     memcpy(input,output,…);   }    ...   }  
Calculer  Y[i]  =  f^k(T,i)     OpenMP       int  main()   {   …   for  (int  etape  =  0;  etape  <  k;  etape++)   {   #pragma  omp  parallel  for   for(  int  n=  debut;  n  <  fin;  n++)      output[n]  =  f(input,n);     memcpy(input,output,…);   }    ...   }   0   1   2   0   1   2   memcpy(input,output,…);     memcpy(input,output,…);    
Calculer  Y[i]  =  f^k(T,i)     OpenMP       int  main()   {   …   for  (int  etape  =  0;  etape  <  k;  etape++)   {   #pragma  omp  parallel  for   for(  int  n=  debut;  n  <  fin;  n++)      output[n]  =  f(input,n);     memcpy(input,output,…);   }    ...   }   0   1   2   memcpy(input,output,…);     memcpy(input,output,…);     Réduire  le  coût  de  la  parallélisa4on  
Calculer  Y[i]  =  f^k(T,i)     OpenMP   int  main()   {   …   #pragma  omp  parallel     for  (int  etape  =  0;  etape  <  k;  etape++)   {   #pragma  omp  parallel  for   for(  int  n=  debut;  n  <  fin;  n++)      output[n]  =  f(input,n);      //  barrière  implicite    if  (omp_get_thread_num()  ==  0)              memcpy(input,output,…);      #pragma  omp  barrier   }    ...   }   0   1   2   memcpy(input,output,…);     memcpy(input,output,…);    
Calculer  Y[i]  =  f^k(T,i)     OpenMP   int  main()   {   …   #pragma  omp  parallel   for  (int  etape  =  0;  etape  <  k;  etape++)   {   #pragma  omp  parallel  for   for(  int  n=  debut;  n  <  fin;  n++)      output[n]  =  f(input,n);      //  barrière  implicite   #pragma  omp  master    memcpy(input,output,…);    #pragma  omp  barrier   }    ...   }   0   1   2   memcpy(input,output,…);     memcpy(input,output,…);    
Calculer  Y[i]  =  f^k(T,i)     OpenMP   int  main()   {   …   #pragma  omp  parallel   for  (int  etape  =  0;  etape  <  k;  etape++)   {   #pragma  omp  parallel  for   for(  int  n=  debut;  n  <  fin;  n++)      output[n]  =  f(input,n);       #pragma  omp  single    memcpy(input,output,…);   //  barrière  implicite   }    ...   }   0   1   2   memcpy(input,output,…);     memcpy(input,output,…);  
Calculer  Y[i]  =  f^k(T,i)   Pthread     void  appliquer_f(void  *i)     {      int  debut  =  (int)  i  *  TAILLE_TRANCHE;    int  fin  =  ((int)  i+1)  *  TAILLE_TRANCHE;        double  *entree  =  input;    double  *sorTe  =  output;       for(int  etape=0;  etape  <  k;  etape++)   {    for(  int  n=  debut;  n  <  fin;  n++)      sor4e[n]  =  f(entree,n);      echanger(entree,sorTe);      barrier_wait(&b);  //  aRendre   }   }       int  main()   {   …   for  (int  i  =  0;  i    <  NB_THREADS;  i++)        pthread_create(&threads[I],  NULL,                                                                                appliquer_f,  (void  *)i);        for  (int  i  =  0;  i    <  NB_THREADS;  i++)        pthread_join(threads[I],  NULL);        ...   }  
Calculer  Y[i]  =  f^k(T,i)     OpenMP   int  main()   {      double  *entree  =  input;    double  *sorTe  =  output;   …   #pragma  omp  parallel  private(entree,  sorTe)   for  (int  etape  =  0;  etape  <  k;  etape++)   {   #pragma  omp  parallel  for   for(  int  n=  debut;  n  <  fin;  n++)      output[n]  =  f(input,n);      echange  (&entree,&sorTe);         }    ...   }   0   1   2  
Calculer  Y[i]  =  f^k(T,i)     OpenMP   int  main()   {      double  *entree  =  input;    double  *sorTe  =  output;   …   #pragma  omp  parallel  firstprivate(entree,  sorTe)   for  (int  etape  =  0;  etape  <  k;  etape++)   {   #pragma  omp  parallel  for   for(  int  n=  debut;  n  <  fin;  n++)      output[n]  =  f(input,n);      echange  (&entree,&sorTe);         }    ...   }   0   1   2  
omp  parallel     #pragma  omp  parallel     • barrière  implicite  à  la  fin  de  la  sec4on  parallèle   • nombre  de  threads  :  num_threads(n)   – Dépendant  de  l’implémenta4on   – Au  maximum  n  threads  exécuteront  la  sec4on   •   clauses  sur  le  partage  des  variables   – default  (  none  |  shared  |  private  |  firstprivate  )   – private(…)  shared(…)     – fisrtpivate(…)  :  la  valeur  de  la  variable  est  recopiée  à  l’ini4alisa4on  du  thread   – lastprivate(…)  :  affecté  par  le  thread  exécutant  la  dernière  affecta4on  du  programme   séquen4el   #omp  threadprivate()   – variable  persistente  conservée  de  sec4on  parallèle  en  sec4on  parallèle  
omp  for   #pragma  omp  for     • nowait   – Suppression  de  la  barrière  implicite   • schedule(mode,taille)   – (staTc)  :  distribu4on  par  bloc   – (sta4c,1)  :  distribu4on  cyclique   – (sta4c,n)  :  cyclique  par  tranche  de  n   – (dynamic,n)  :  à  la  demande  par  tranche  de  n   – (guided,n)  :  à  la  demande,  par  tranches  de  tailles  décroissantes  =  MAX(n,     (nb  indices  restants)  /  nb_threads)   – (runTme)  :  suivant  la  valeur  de  la  variable  OMP_SCHEDULE     – (auto)  :  suivant  le  compilateur  et/ou  le  support  d’exécu4on    
Schedule    (d’après  sun)   !" !"#$%&'(' )*++,*-./#01-2/*+,*-/+345*6$ !"#$%&'()*+,,-./01.2&3%"4$4)564 #$%&'()""* +,-(-./-012-34 7 87 '77 '87 977 987 :77 :87 ;77 ;87 877 3 2 1 0 3 2 1 0 3 2 1 0 546417 8936217:(* ;<18-8:(* #4-0641=3(><2?-0 +,0-68(#@ !""#$%&'(%$)*+#)*#,#%-'&(.+
omp  for  collapse   #pragma  parallel  omp  for  collapse(2)  schedule(runTme)      for  (int  i  =  0;  i  <  N;  i++)      for  (int  j  =  0;  j  <  N;  j++)        t[i][j]  =  omp_get_thread_num();     OMP_SCHEDULE=sta4c  OMP_NUM_THREADS=5  ./a.out        0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4   OMP_SCHEDULE=guided  OMP_NUM_THREADS=4          0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0      0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0      0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0      0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0      0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0      3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3      3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3      3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3      3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    1    1    1    1    1      1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1      1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1      1    1    1    1    1    1    1    1    1    1    1    1    0    0    0    0    0    0    0    0      0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0      0    0    0    0    0    0    0    0    0    0    0    0    0    0    3    3    3    3    3    3      3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3      3    3    3    3    3    3    1    1    1    1    1    1    1    1    1    1    1    1    1    1      1    1    1    1    1    1    1    1    1    1    3    3    3    3    3    3    3    3    3    3      3    3    3    3    3    3    3    3    0    0    0    0    0    0    0    0    0    0    0    0      0    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    3      3    3    3    3    3    2    2    2    2    1    1    1    3    3    0    0    2    1    3    3   OMP_SCHEDULE=dynamic,2  OMP_NUM_THREADS=5      0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0      0    0    0    0    0    0    0    0    0    0    0    0    1    1    0    0    0    0    0    0      0    0    1    1    0    0    1    1    0    0    0    0    1    1    0    0    1    1    0    0      1    1    0    0    1    1    1    1    3    3    0    0    1    1    2    2    0    0    1    1      0    0    3    3    0    0    2    2    1    1    3    3    0    0    2    2    4    4    1    1      0    0    3    3    2    2    4    4    0    0    1    1    3    3    2    2    0    0    4    4      1    1    3    3    0    0    2    2    4    4    1    1    3    3    0    0    2    2    4    4      1    1    0    0    3    3    2    2    4    4    0    0    1    1    3    3    2    2    0    0      4    4    1    1    3    3    0    0    2    2    4    4    1    1    0    0    3    3    2    2      4    4    0    0    1    1    3    3    2    2    0    0    4    4    1    1    3    3    0    0      2    2    4    4    1    1    0    0    3    3    2    2    4    4    0    0    1    1    3    3      2    2    0    0    4    4    1    1    3    3    2    2    0    0    4    4    1    1    3    3      0    0    2    2    4    4    1    1    0    0    3    3    2    2    4    4    0    0    1    1      3    3    2    2    0    0    4    4    1    1    3    3    0    0    2    2    4    4    1    1      0    0    3    3    2    2    4    4    0    0    1    1    3    3    2    2    0    0    4    4      1    1    3    3    0    0    2    2    4    4    1    1    0    0    3    3    2    2    4    4      0    0    1    1    3    3    2    2    0    0    4    4    1    1    3    3    0    0    2    2      4    4    1    1    0    0    3    3    3    3    2    2    4    4    0    0    1    1    3    3      2    2    0    0    4    4    1    1    3    3    0    0    2    2    4    4    1    1    0    0      3    3    2    2    4    4    0    0    1    1    3    3    2    2    0    0    4    4    1    1  
Paralléliser  le  jeu  de  la  vie     int  T[2][DIM][DIM];   for(etape  =  0;  etape  <  ETAPE;  etape++)   {    in  =  1-­‐in;    out  =  1  -­‐  out;      nb_cellules  =  0;            for(i=1;  i  <  DIM-­‐1;  i++)          for(j=1;  j  <  DIM-­‐1;  i++)          {        T[out][i][j]  =f(T[in][i][j],  T[in][i-­‐1][j],  ...)            if  (T[out][i][j]  >  0)            nb_cellules++;            }                prin[("%d  =>  %d",  etape,  nb_cellules);       }    
Paralléliser  le  jeu  de  la  vie     #pragma  omp  parallel  shared(nb_cellules)  private(in,out)   for(etape  =  0;  etape  <  ETAPE;  etape++)   {    in  =  1-­‐in;    out  =  1  -­‐  out;      nb_cellules  =  0;   #pragma  omp  for  collapse(2)          for(i=1;  i  <  DIM-­‐1;  i++)          for(j=1;  j  <  DIM-­‐1;  i++)          {        T[out][i][j]  =f(T[in][i][j],  T[in][i-­‐1][j],  ...)            if  (T[out][i][j]  >  0)            nb_cellules++;            }   #pragma  omp  single                prin[("%d  =>  %d",  etape,  nb_cellules);     }  
Paralléliser  le  jeu  de  la  vie     #pragma  omp  parallel  shared(nb_cellules)  private(in,out)   for(etape  =  0;  etape  <  ETAPE;  etape++)   {    in  =  1-­‐in;    out  =  1  -­‐  out;      nb_cellules  =  0;   #pragma  omp  for  collapse(2)          for(i=1;  i  <  DIM-­‐1;  i++)          for(j=1;  j  <  DIM-­‐1;  i++)          {        T[out][i][j]  =f(T[in][i][j],  T[in][i-­‐1][j],  ...)            if  (T[out][i][j]  >  0)     #pragma  omp  criTcal            nb_cellules++;            }   #pragma  omp  single                prin[("%d  =>  %d",  etape,  nb_cellules);     }  
Paralléliser  le  jeu  de  la  vie     #pragma  omp  parallel  shared(nb_cellules)  private(in,out)   for(etape  =  0;  etape  <  ETAPE;  etape++)   {    in  =  1-­‐in;    out  =  1  -­‐  out;      nb_cellules  =  0;   #pragma  omp  for  collapse(2)          for(i=1;  i  <  DIM-­‐1;  i++)          for(j=1;  j  <  DIM-­‐1;  i++)          {        T[out][i][j]  =f(T[in][i][j],  T[in][i-­‐1][j],  ...)            if  (T[out][i][j]  >  0)     #pragma  omp  atomic            nb_cellules++;            }   #pragma  omp  single                prin[("%d  =>  %d",  etape,  nb_cellules);     }  
Cri4cal  vs  atomic   #pragma  omp  cri4cal  [iden1ficateur]   – Sans  iden4ficateur  un  mutex  par   défaut  est  u4lisé   – Pas  de  barrière  implicite   • #pragma  atomic   – Remplacé  au  besoin  par  un  cri4cal       #pragma  omp  parallel  for  collapse(2)              for  (i  =  0;  i  <  2000;  i++)                for  (j  =  0;  j  <  2000;  j++)   #pragma  omp  atomic                      x++;         Nb   threads   criTcal   atomic   sans   openMP   0,018   0,018   1   0,2   0,15   2   1,7   0,7   3   2,4   0,9   6   6   1,2   12   12   1,2   24   24   1,2   48   47   1,2  
Paralléliser  le  jeu  de  la  vie     #pragma  omp  parallel  shared(nb_cellules)  private(in,out)   for(etape  =  0;  etape  <  ETAPE;  etape++)   {    in  =  1-­‐in;    out  =  1  -­‐  out;      nb_cellules  =  0;   #pragma  omp  for  collapse(2)  reducTon(+:nb_cellules)        for(i=1;  i  <  DIM-­‐1;  i++)          for(j=1;  j  <  DIM-­‐1;  i++)          {        T[out][i][j]  =f(T[in][i][j],  T[in][i-­‐1][j],  ...)            if  (T[out][i][j]  >  0)            nb_cellules++;            }   #pragma  omp  single                prin[("%d  =>  %d",  etape,  nb_cellules);     }  
Paralléliser  le  jeu  de  la  vie     #pragma  omp  parallel  shared(nb_cellules)  private(in,out)   for(etape  =  0;  etape  <  ETAPE;  etape++)   {    in  =  1-­‐in;  out  =  1  –  out;  nb_cellules1  =  0;  nb_cellules2  =  0;   #pragma  omp  for  collapse(2)  reducTon(+:nb_cellules1,nb_cellules2)        for(i=1;  i  <  DIM-­‐1;  i++)          for(j=1;  j  <  DIM-­‐1;  i++)  {        if(etape%2)          T[out][i][j]  =f(T[in][i][j],  T[in][i-­‐1][j],  ...)              if  (T[out][i][j]  >  0)            nb_cellules1++;          else  …          }   #pragma  omp  single  nowait    if(etape  %  2)  {                    prin[("%d  =>  %d",  etape,  nb_cellules1);                    nb_cellules1=0;    }  else  {  ….     }  
OpenMP  détails   sec4ons   #pragma  omp  sec4ons   {      #pragma  omp  sec4on              {                ...              }                #pragma  omp  sec4on              {              ...              }   }   #pragma  omp  for  schedule  (dynamic)   for(i  =  0;  i  <  =  S;  i++)      switch(i)              {    case  0:  …  ;  break  ;    case  1:  …  ;  break  ;    …    case  S:  …  ;  break  ;    default  :  abort();                }   }  
OpenMP  détails   •    clause  nowait   – Supprime  la  barrière  par  défaut   • for,  single,  sec4on,…   – La  mémoire  n’est  plus  «  synchronisée  »  à  la  fin  de   la  construc4on   • #pragma  omp  flush()  
Parallélisme  imbriqué   • Imbriquer  des  équipes  de  threads     #omp  parallel  num_threads(externe)   {     //  distribu4ons  des  zones  de  travail       #omp  parallel  for  num_threads(interne)      {      //  parallélisa4on  du  travail  au  sein  d’une  zone        }      
Parallélisme  imbriqué     • Exprimer  plus  de  parallélisme   – Adapter  le  parallélisme  au  problème   – Méthode  récursive  «  diviser  pour  régner  »   • Difficultés:   – Surcoût  à  la  créa4on  lié  à  la  créa4on  /  d’équipe   – Stabilité  d’exécu4on  (support  d’exécu4on,   ordonnanceur  du  système)   – Qualité  du  par4onnement  des  threads  
Parallélisme  imbriqué     Qualité  du  support  d’exécu4on   GOMP  3   ICC   Forest   atomic   0,52   0,87   0,49   barrier   75,51   26,98   27,56   cri4cal   12,90   39,01   4,13   for   80,44   28,17   27,33   lock   4,69   4,41   4,06   parallel   3209,75   304,94   171,66   parallel  for   3222,49   311,58   170,56   reduc4on   3220,41   454,20   171,58   Benchmark Nested-EPCC : surcout (µs) de l’invocation des mot-clés OpenMP en contexte de parallélisme imbriqué, sur une machine à 16 coeurs
Parallélisme  imbriqué    le  benchmark  BT-­‐MZ   } Parallélisa4on  à  deux  niveaux   } Plusieurs  simula4ons  sur  des  zones   différentes   } Plusieurs  threads  pour  traiter   chacune  des  zones   } Imbrica4on  de  régions  parallèles   OpenMP   } Alloca4on  mémoire:  first-­‐touch     } Parallélisme externe irrégulier } Différentes charges de travail selon les zones } Parallélisme interne régulier } Les threads d’une même zone ont la même quantité de travail à effectuer 2  zones  traitées  en   parallèle   4  threads  par  zone   Arbre  de  threads  obtenu  lors  d’une   exécu1on  «  2x4  »  du  benchmark  BT-­‐MZ  
BT-­‐MZ:  Résultats  expérimentaux   Outer     x  Inner   GOMP  3   Intel   Cache   Original   Info  de  charge   4  x  4   9.4   13.8   14.1   14.1   16  x  1   14.1   13.9   14.1   14.1   16  x  4   11.6   6.1   14.1   14.9   16  x  8   11.5   4.0   14.4   15.0   32  x  1   12.6   10.3   13.5   13.8   32  x  4   11.2   3.4   14.3   14.8   32  x  8   10.9   2.8   14.5   14.7   Accélérations obtenues sur la machine Kwak avec la classe C du benchmark BT-MZ
Parallélisme  imbriqué   Diviser  pour  régner   • Extraire  beaucoup  de  parallélisme   • Pouvoir  traiter  des  pb  irréguliers     void  fun  (  int  p)   {    #pragma  omp  parallel  for      for(i  …)      …      fun(p+1)  ;       }  
Parallélisme  imbriqué   Diviser  pour  régner   • Extraire  beaucoup  de  parallélisme   • Pouvoir  traiter  des  pb  irréguliers     void  fun  (  int  p)   {    #pragma  omp  parallel  for  if  (p  <  PROFMAX)    for(i  …)      …      fun(p+1)  ;       }  
Qsort   hRp://wikis.sun.com/display/openmp     void  quick_sort  (int  p,  int  r,  float  *data)   {          if  (p  <  r)  {                          int  q  =  par44on  (p,  r,  data);                          #pragma  omp  parallel  sec4ons  firstprivate(data,  p,  q,  r)                          {                                  #pragma  omp  sec4on                                  quick_sort  (p,  q-­‐1,  data,  low_limit);                                  #pragma  omp  sec4on                                  quick_sort  (q+1,  r,  data,  low_limit);                          }                  }          }   }  
Parallélisme  imbriqué   Diviser  pour  régner   Ordonnancement  de  l’applica4on  MPU   – Objec4f  :  trouver  une  fonc4on  mathéma4que   approximant  la  surface  d’un  objet  défini  par  un   nuage  de  points  
Exécu4on  avec  Cache   } Distribu4on  gloutonne    
Exécu4on  avec  Cache  
Exécu4on  avec  Cache   OK  !   OK  !  
Exécu4on  avec  Cache   OK  !   OK  !  
Exécu4on  avec  Cache   OK  !   OK  !   } Vol  de  travail  de  proche  en  proche  pour  rééquilibrer  la   charge  
Exécu4on  avec  Cache   OK  !   OK  !   } Vol  de  travail  de  proche  en  proche  pour  rééquilibrer  la   charge  
Exécu4on  avec  Cache   OK  !   OK  !  
MPU  :  Accéléra4on  sur  16  cœurs   1 3 5 7 9 11 13 15 2 4 8 16 Nombre de coeurs Accélération libGOMP Null Cache ICC } Exécu4on  sur  un  nuage  de  437644  points   } 101185  créa4ons  de  threads   } Profondeur  maximale  de  récursion  :  15  

Contenu connexe

PDF
Systèmes parallèles-programmation des sys
parayyoubbenmns
 
PDF
Lattice Boltzmann sur architecture multicoeurs vectorielle - Une approche de ...
parJoel Falcou
 
PPTX
Chap5THREADChap5Chap5THREADChap5THREADTHREAD.pptx
parHarouNJlssMa
 
PPT
Amina 2010 workshop slides final version
parRMwebsite
 
PDF
Traitement des données massives (INF442, A4)
parFrank Nielsen
 
PDF
03_ProgrammationSystemeLinux_Thread.pdf
parLarbaSAWADOGO2
 
PDF
Traitement des données massives (INF442, A2)
parFrank Nielsen
 
PDF
UE4-Protocoles de routage - introduction
parangelo119154
 
Systèmes parallèles-programmation des sys
parayyoubbenmns
 
Lattice Boltzmann sur architecture multicoeurs vectorielle - Une approche de ...
parJoel Falcou
 
Chap5THREADChap5Chap5THREADChap5THREADTHREAD.pptx
parHarouNJlssMa
 
Amina 2010 workshop slides final version
parRMwebsite
 
Traitement des données massives (INF442, A4)
parFrank Nielsen
 
03_ProgrammationSystemeLinux_Thread.pdf
parLarbaSAWADOGO2
 
Traitement des données massives (INF442, A2)
parFrank Nielsen
 
UE4-Protocoles de routage - introduction
parangelo119154
 

Plus de angelo119154

PDF
UE4-Protocoles de routage - RIP version 2
parangelo119154
 
PDF
Introduction aux réseaux informatiques - la couche transport
parangelo119154
 
PDF
Introduction aux réseaux informatiques - Routage
parangelo119154
 
PDF
Introduction aux réseaux informatiques - Couche réseau
parangelo119154
 
PDF
Introduction aux réseaux informatiques - MAC Ethernet
parangelo119154
 
PPTX
Introduction aux réseaux informatiques - présentation couche MAC/LLC
parangelo119154
 
PPTX
Introduction aux réseaux informatiques - présentation OSI et couche physique
parangelo119154
 
PPTX
Lecture 02_ Linear Model - machine learning
parangelo119154
 
PPTX
Neural Networks and deep learning: activation loss
parangelo119154
 
PDF
Introduction to CUDA programming in C language
parangelo119154
 
PPTX
Apports de l'intellgence artificielle à la smart-agriculture
parangelo119154
 
PDF
Introduction to Diffusion Models on deep learning
parangelo119154
 
UE4-Protocoles de routage - RIP version 2
parangelo119154
 
Introduction aux réseaux informatiques - la couche transport
parangelo119154
 
Introduction aux réseaux informatiques - Routage
parangelo119154
 
Introduction aux réseaux informatiques - Couche réseau
parangelo119154
 
Introduction aux réseaux informatiques - MAC Ethernet
parangelo119154
 
Introduction aux réseaux informatiques - présentation couche MAC/LLC
parangelo119154
 
Introduction aux réseaux informatiques - présentation OSI et couche physique
parangelo119154
 
Lecture 02_ Linear Model - machine learning
parangelo119154
 
Neural Networks and deep learning: activation loss
parangelo119154
 
Introduction to CUDA programming in C language
parangelo119154
 
Apports de l'intellgence artificielle à la smart-agriculture
parangelo119154
 
Introduction to Diffusion Models on deep learning
parangelo119154
 

Introduction à la programmation parallèle avec OpenMP

  • 1.
    OpenMP   www.openmp.org   •Une  API  pour  la  programma4on  parallèle  en  mémoire  partagée   – C,  C++,  Fortran   – Portable   – Porté  par  l’Architecture  Review  Board  (Intel,  IBM,  AMD,  MicrosoD,   Cray,  Oracle,  NEC…)   • Basé  sur  des  annota4ons  :  #pragma  omp  direc1ve   • et  des  fonc4ons:  omp_fonc1on()   • Permet  de  paralléliser  un  code  de  façon  plus  ou  moins  intrusive  un   code   – Plus  on  en  dit  plus  on  a  de  performance   – Facile  à  meRre  en  œuvre  par  un  non  spécialiste…  Trop  facile  ?   • Ne  permet  pas  de  créer  ses  propres  ou4l  de  synchronisa4on   • hRps://compu4ng.llnl.gov/tutorials/openMP/  
  • 2.
    Hello  world  !     int  main()   {      prin[("bonjourn");      prin[("au  revoirn")  ;          return  EXIT_SUCCESS;   }           >  gcc  bon.c   >./a.out   bonjour       au  revoir   >  
  • 3.
    Hello  world  !   #include  <omp.h>     int  main()   {   #pragma  omp  parallel      prin[("bonjourn");        prin[("au  revoirn")  ;          return  EXIT_SUCCESS;   }     >  gcc  –fopenmp  bon.c   >./a.out   bonjour       bonjour     bonjour     bonjour     au  revoir   >      
  • 4.
    Hello  world  !   #include  <omp.h>     int  main()   {   #pragma  omp  parallel      prin[("bonjourn");        prin[("au  revoirn")  ;          return  EXIT_SUCCESS;   }       >  gcc  –fopenmp  bon.c   >OPENMP_NUMTHREADS=3  ./a.out   bonjour       bonjour     bonjour     au  revoir   >      
  • 5.
    Hello  world  !   #include  <omp.h>     int  main()   {   #pragma  omp  parallel      prin[("bonjourn");        prin[("au  revoirn")  ;          return  EXIT_SUCCESS;   }   >  export  OPENMP_NUMTHREADS=3     >  gcc  –fopenmp  bon.c   >./a.out   bonjour       bonjour     bonjour     au  revoir   >      
  • 6.
    Hello  world  !   #include  <omp.h>   int  main()   {   #pragma  omp  parallel  num_threads(3)      prin[("bonjourn");        prin[("au  revoirn")  ;      return  EXIT_SUCCESS;   }     >  gcc  –fopenmp  bon.c   >./a.out   bonjour       bonjour     bonjour     au  revoir   >      
  • 7.
    Hello  world  !   #include  <omp.h>   int  main()   {   omp_set_num_threads(3);   #pragma  omp  parallel      prin[("bonjourn");        prin[("au  revoirn")  ;      return  EXIT_SUCCESS;   }   >  gcc  –fopenmp  bon.c   >./a.out   bonjour       bonjour     bonjour     au  revoir   >      
  • 8.
    Parallélisme  fork-­‐join   •Un  unique  thread  exécute  séquen4ellement   le  code  de  main.     • Lors  de  la  rencontre  d’un  bloc  parallèle,  tout   thread     – crée  une  équipe  de  threads     – la  charge  d'exécuter  une  fonc4on   correspondant  au  bloc  parallèle     – rejoint  en  tant  que  maître  l’équipe.     • À  la  fin  du  bloc  parallèle     – les  threads  d’une  même  équipe  s'aRendent   au  moyen  d'une  barrière  implicite       – les  threads  esclaves  sont  démobilisés   – le  thread  maître  retrouve  son  équipe   précédente     #pragma  omp  parallel   Barrière   0   1   2  
  • 9.
    Hello  world  !   #include  <omp.h>   int  main()   {   #pragma  omp  parallel      {    prin[("bonjourn");      //  barrière  implicite      }   prin[("au  revoirn")  ;      return  EXIT_SUCCESS;   }        
  • 10.
    Traduc4on  en  pthread   #pragma  omp  parallel   f();               {   pthread_t  4d[K];   for(int  i=1;i<k;i++)    pthread_create(4d+i,0,f,i);   f(0);     for(int  i=1;i<k;i++)    pthread_join(4d[i]);   }      
  • 11.
    Calcul  en  parallèle  de  Y[i]  =  f(T,i)     Pthread   #define  NB_ELEM  (TAILLE_TRANCHE  *   NB_THREADS)   pthread_t  threads[NB_THREADS];   double  input[NB_ELEM],  output[NB_ELEM];       void  appliquer_f(void  *i)     {      int  debut  =  (int)  i  *  TAILLE_TRANCHE;    int  fin  =  ((int)  i+1)  *  TAILLE_TRANCHE;        for(  int  n=  debut;  n  <  fin;  n++)      output[n]  =  f(input,n);       //    pthread_exit(NULL);   }       int  main()   {   …      for  (int  i  =  0;  i    <  NB_THREADS;  i++)        pthread_create(&threads[I],  NULL,                                                                                appliquer_f,  (void  *)i);        for  (int  i  =  0;  i    <  NB_THREADS;  i++)        pthread_join(threads[I],  NULL);        ...   }   Parallélisa4on  efficace  si  équilibrée  
  • 12.
    Calcul  en  parallèle  de  Y[i]  =  f(T,i)     OpenMP   #define  NB_ELEM  (TAILLE_TRANCHE  *   NB_THREADS)   pthread_t  threads[NB_THREADS];   double  input[NB_ELEM],  output[NB_ELEM];       void  appliquer_f(void  *i)     {      int  debut  =  (int)  i  *  TAILLE_TRANCHE;    int  fin  =  ((int)  i+1)  *  TAILLE_TRANCHE;        for(  int  n=  debut;  n  <  fin;  n++)      output[n]  =  f(input,n);       //    pthread_exit(NULL);   }       int  main()   {   …    #pragma  omp  parallel                    appliquer_f,  (omp_get_thread_num());      ...   }  
  • 13.
    Calcul  en  parallèle  de  Y[i]  =  f(T,i)     distribu4on  d’indices   #define  NB_ELEM  (TAILLE_TRANCHE  *   NB_THREADS)   pthread_t  threads[NB_THREADS];   double  input[NB_ELEM],  output[NB_ELEM];       /*  void  appliquer_f(void  *i)     {      int  debut  =  (int)  i  *  TAILLE_TRANCHE;    int  fin  =  ((int)  i+1)  *  TAILLE_TRANCHE;        for(  int  n=  debut;  n  <  fin;  n++)      output[n]  =  f(input,n);       //    pthread_exit(NULL);   }  */     int  main()   {   …    #pragma  omp  parallel                #pragma  omp  for   for(  int  n=  debut;  n  <  fin;  n++)      output[n]  =  f(input,n);      ...   }  
  • 14.
    Calculer  Y[i]  =  f^k(T,i)    pthread     #define  NB_ELEM  (TAILLE_TRANCHE  *   NB_THREADS)   pthread_t  threads[NB_THREADS];   double  input[NB_ELEM],  output[NB_ELEM];       void  appliquer_f(void  *i)     {      int  debut  =  (int)  i  *  TAILLE_TRANCHE;    int  fin  =  ((int)  i+1)  *  TAILLE_TRANCHE;        for(  int  n=  debut;  n  <  fin;  n++)      output[n]  =  f(input,n);       //    pthread_exit(NULL);   }       int  main()   {   …   for  (int  etape  =  0;  etape  <  k;  etape++)   {      for  (int  i  =  0;  i    <  NB_THREADS;  i++)        pthread_create(&threads[I],  NULL,                                                                                appliquer_f,  (void  *)i);        for  (int  i  =  0;  i    <  NB_THREADS;  i++)        pthread_join(threads[I],  NULL);       memcpy(input,output,…);   }    ...   }  
  • 15.
    Calculer  Y[i]  =  f^k(T,i)     OpenMP   int  main()   {   …   for  (int  etape  =  0;  etape  <  k;  etape++)   {   #pragma  omp  parallel  for   for(  int  n=  debut;  n  <  fin;  n++)      output[n]  =  f(input,n);     memcpy(input,output,…);   }    ...   }  
  • 16.
    Calculer  Y[i]  =  f^k(T,i)     OpenMP       int  main()   {   …   for  (int  etape  =  0;  etape  <  k;  etape++)   {   #pragma  omp  parallel  for   for(  int  n=  debut;  n  <  fin;  n++)      output[n]  =  f(input,n);     memcpy(input,output,…);   }    ...   }   0   1   2   0   1   2   memcpy(input,output,…);     memcpy(input,output,…);    
  • 17.
    Calculer  Y[i]  =  f^k(T,i)     OpenMP       int  main()   {   …   for  (int  etape  =  0;  etape  <  k;  etape++)   {   #pragma  omp  parallel  for   for(  int  n=  debut;  n  <  fin;  n++)      output[n]  =  f(input,n);     memcpy(input,output,…);   }    ...   }   0   1   2   memcpy(input,output,…);     memcpy(input,output,…);     Réduire  le  coût  de  la  parallélisa4on  
  • 18.
    Calculer  Y[i]  =  f^k(T,i)     OpenMP   int  main()   {   …   #pragma  omp  parallel     for  (int  etape  =  0;  etape  <  k;  etape++)   {   #pragma  omp  parallel  for   for(  int  n=  debut;  n  <  fin;  n++)      output[n]  =  f(input,n);      //  barrière  implicite    if  (omp_get_thread_num()  ==  0)              memcpy(input,output,…);      #pragma  omp  barrier   }    ...   }   0   1   2   memcpy(input,output,…);     memcpy(input,output,…);    
  • 19.
    Calculer  Y[i]  =  f^k(T,i)     OpenMP   int  main()   {   …   #pragma  omp  parallel   for  (int  etape  =  0;  etape  <  k;  etape++)   {   #pragma  omp  parallel  for   for(  int  n=  debut;  n  <  fin;  n++)      output[n]  =  f(input,n);      //  barrière  implicite   #pragma  omp  master    memcpy(input,output,…);    #pragma  omp  barrier   }    ...   }   0   1   2   memcpy(input,output,…);     memcpy(input,output,…);    
  • 20.
    Calculer  Y[i]  =  f^k(T,i)     OpenMP   int  main()   {   …   #pragma  omp  parallel   for  (int  etape  =  0;  etape  <  k;  etape++)   {   #pragma  omp  parallel  for   for(  int  n=  debut;  n  <  fin;  n++)      output[n]  =  f(input,n);       #pragma  omp  single    memcpy(input,output,…);   //  barrière  implicite   }    ...   }   0   1   2   memcpy(input,output,…);     memcpy(input,output,…);  
  • 21.
    Calculer  Y[i]  =  f^k(T,i)   Pthread     void  appliquer_f(void  *i)     {      int  debut  =  (int)  i  *  TAILLE_TRANCHE;    int  fin  =  ((int)  i+1)  *  TAILLE_TRANCHE;        double  *entree  =  input;    double  *sorTe  =  output;       for(int  etape=0;  etape  <  k;  etape++)   {    for(  int  n=  debut;  n  <  fin;  n++)      sor4e[n]  =  f(entree,n);      echanger(entree,sorTe);      barrier_wait(&b);  //  aRendre   }   }       int  main()   {   …   for  (int  i  =  0;  i    <  NB_THREADS;  i++)        pthread_create(&threads[I],  NULL,                                                                                appliquer_f,  (void  *)i);        for  (int  i  =  0;  i    <  NB_THREADS;  i++)        pthread_join(threads[I],  NULL);        ...   }  
  • 22.
    Calculer  Y[i]  =  f^k(T,i)     OpenMP   int  main()   {      double  *entree  =  input;    double  *sorTe  =  output;   …   #pragma  omp  parallel  private(entree,  sorTe)   for  (int  etape  =  0;  etape  <  k;  etape++)   {   #pragma  omp  parallel  for   for(  int  n=  debut;  n  <  fin;  n++)      output[n]  =  f(input,n);      echange  (&entree,&sorTe);         }    ...   }   0   1   2  
  • 23.
    Calculer  Y[i]  =  f^k(T,i)     OpenMP   int  main()   {      double  *entree  =  input;    double  *sorTe  =  output;   …   #pragma  omp  parallel  firstprivate(entree,  sorTe)   for  (int  etape  =  0;  etape  <  k;  etape++)   {   #pragma  omp  parallel  for   for(  int  n=  debut;  n  <  fin;  n++)      output[n]  =  f(input,n);      echange  (&entree,&sorTe);         }    ...   }   0   1   2  
  • 24.
    omp  parallel     #pragma  omp  parallel     • barrière  implicite  à  la  fin  de  la  sec4on  parallèle   • nombre  de  threads  :  num_threads(n)   – Dépendant  de  l’implémenta4on   – Au  maximum  n  threads  exécuteront  la  sec4on   •   clauses  sur  le  partage  des  variables   – default  (  none  |  shared  |  private  |  firstprivate  )   – private(…)  shared(…)     – fisrtpivate(…)  :  la  valeur  de  la  variable  est  recopiée  à  l’ini4alisa4on  du  thread   – lastprivate(…)  :  affecté  par  le  thread  exécutant  la  dernière  affecta4on  du  programme   séquen4el   #omp  threadprivate()   – variable  persistente  conservée  de  sec4on  parallèle  en  sec4on  parallèle  
  • 25.
    omp  for   #pragma  omp  for     • nowait   – Suppression  de  la  barrière  implicite   • schedule(mode,taille)   – (staTc)  :  distribu4on  par  bloc   – (sta4c,1)  :  distribu4on  cyclique   – (sta4c,n)  :  cyclique  par  tranche  de  n   – (dynamic,n)  :  à  la  demande  par  tranche  de  n   – (guided,n)  :  à  la  demande,  par  tranches  de  tailles  décroissantes  =  MAX(n,     (nb  indices  restants)  /  nb_threads)   – (runTme)  :  suivant  la  valeur  de  la  variable  OMP_SCHEDULE     – (auto)  :  suivant  le  compilateur  et/ou  le  support  d’exécu4on    
  • 26.
    Schedule    (d’après  sun)   !" !"#$%&'(' )*++,*-./#01-2/*+,*-/+345*6$ !"#$%&'()*+,,-./01.2&3%"4$4)564 #$%&'()""* +,-(-./-012-34 7 87 '77 '87 977 987 :77 :87 ;77 ;87 877 3 2 1 0 3 2 1 0 3 2 1 0 546417 8936217:(* ;<18-8:(* #4-0641=3(><2?-0 +,0-68(#@ !""#$%&'(%$)*+#)*#,#%-'&(.+
  • 27.
    omp  for  collapse   #pragma  parallel  omp  for  collapse(2)  schedule(runTme)      for  (int  i  =  0;  i  <  N;  i++)      for  (int  j  =  0;  j  <  N;  j++)        t[i][j]  =  omp_get_thread_num();     OMP_SCHEDULE=sta4c  OMP_NUM_THREADS=5  ./a.out        0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4      0    1    2    3    4    0    1    2    3    4    0    1    2    3    4    0    1    2    3    4   OMP_SCHEDULE=guided  OMP_NUM_THREADS=4          0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0      0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0      0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0      0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0      0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0      3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3      3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3      3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3      3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    1    1    1    1    1      1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1      1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1      1    1    1    1    1    1    1    1    1    1    1    1    0    0    0    0    0    0    0    0      0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0      0    0    0    0    0    0    0    0    0    0    0    0    0    0    3    3    3    3    3    3      3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3    3      3    3    3    3    3    3    1    1    1    1    1    1    1    1    1    1    1    1    1    1      1    1    1    1    1    1    1    1    1    1    3    3    3    3    3    3    3    3    3    3      3    3    3    3    3    3    3    3    0    0    0    0    0    0    0    0    0    0    0    0      0    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    1    3      3    3    3    3    3    2    2    2    2    1    1    1    3    3    0    0    2    1    3    3   OMP_SCHEDULE=dynamic,2  OMP_NUM_THREADS=5      0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0    0      0    0    0    0    0    0    0    0    0    0    0    0    1    1    0    0    0    0    0    0      0    0    1    1    0    0    1    1    0    0    0    0    1    1    0    0    1    1    0    0      1    1    0    0    1    1    1    1    3    3    0    0    1    1    2    2    0    0    1    1      0    0    3    3    0    0    2    2    1    1    3    3    0    0    2    2    4    4    1    1      0    0    3    3    2    2    4    4    0    0    1    1    3    3    2    2    0    0    4    4      1    1    3    3    0    0    2    2    4    4    1    1    3    3    0    0    2    2    4    4      1    1    0    0    3    3    2    2    4    4    0    0    1    1    3    3    2    2    0    0      4    4    1    1    3    3    0    0    2    2    4    4    1    1    0    0    3    3    2    2      4    4    0    0    1    1    3    3    2    2    0    0    4    4    1    1    3    3    0    0      2    2    4    4    1    1    0    0    3    3    2    2    4    4    0    0    1    1    3    3      2    2    0    0    4    4    1    1    3    3    2    2    0    0    4    4    1    1    3    3      0    0    2    2    4    4    1    1    0    0    3    3    2    2    4    4    0    0    1    1      3    3    2    2    0    0    4    4    1    1    3    3    0    0    2    2    4    4    1    1      0    0    3    3    2    2    4    4    0    0    1    1    3    3    2    2    0    0    4    4      1    1    3    3    0    0    2    2    4    4    1    1    0    0    3    3    2    2    4    4      0    0    1    1    3    3    2    2    0    0    4    4    1    1    3    3    0    0    2    2      4    4    1    1    0    0    3    3    3    3    2    2    4    4    0    0    1    1    3    3      2    2    0    0    4    4    1    1    3    3    0    0    2    2    4    4    1    1    0    0      3    3    2    2    4    4    0    0    1    1    3    3    2    2    0    0    4    4    1    1  
  • 28.
    Paralléliser  le  jeu  de  la  vie     int  T[2][DIM][DIM];   for(etape  =  0;  etape  <  ETAPE;  etape++)   {    in  =  1-­‐in;    out  =  1  -­‐  out;      nb_cellules  =  0;            for(i=1;  i  <  DIM-­‐1;  i++)          for(j=1;  j  <  DIM-­‐1;  i++)          {        T[out][i][j]  =f(T[in][i][j],  T[in][i-­‐1][j],  ...)            if  (T[out][i][j]  >  0)            nb_cellules++;            }                prin[("%d  =>  %d",  etape,  nb_cellules);       }    
  • 29.
    Paralléliser  le  jeu  de  la  vie     #pragma  omp  parallel  shared(nb_cellules)  private(in,out)   for(etape  =  0;  etape  <  ETAPE;  etape++)   {    in  =  1-­‐in;    out  =  1  -­‐  out;      nb_cellules  =  0;   #pragma  omp  for  collapse(2)          for(i=1;  i  <  DIM-­‐1;  i++)          for(j=1;  j  <  DIM-­‐1;  i++)          {        T[out][i][j]  =f(T[in][i][j],  T[in][i-­‐1][j],  ...)            if  (T[out][i][j]  >  0)            nb_cellules++;            }   #pragma  omp  single                prin[("%d  =>  %d",  etape,  nb_cellules);     }  
  • 30.
    Paralléliser  le  jeu  de  la  vie     #pragma  omp  parallel  shared(nb_cellules)  private(in,out)   for(etape  =  0;  etape  <  ETAPE;  etape++)   {    in  =  1-­‐in;    out  =  1  -­‐  out;      nb_cellules  =  0;   #pragma  omp  for  collapse(2)          for(i=1;  i  <  DIM-­‐1;  i++)          for(j=1;  j  <  DIM-­‐1;  i++)          {        T[out][i][j]  =f(T[in][i][j],  T[in][i-­‐1][j],  ...)            if  (T[out][i][j]  >  0)     #pragma  omp  criTcal            nb_cellules++;            }   #pragma  omp  single                prin[("%d  =>  %d",  etape,  nb_cellules);     }  
  • 31.
    Paralléliser  le  jeu  de  la  vie     #pragma  omp  parallel  shared(nb_cellules)  private(in,out)   for(etape  =  0;  etape  <  ETAPE;  etape++)   {    in  =  1-­‐in;    out  =  1  -­‐  out;      nb_cellules  =  0;   #pragma  omp  for  collapse(2)          for(i=1;  i  <  DIM-­‐1;  i++)          for(j=1;  j  <  DIM-­‐1;  i++)          {        T[out][i][j]  =f(T[in][i][j],  T[in][i-­‐1][j],  ...)            if  (T[out][i][j]  >  0)     #pragma  omp  atomic            nb_cellules++;            }   #pragma  omp  single                prin[("%d  =>  %d",  etape,  nb_cellules);     }  
  • 32.
    Cri4cal  vs  atomic   #pragma  omp  cri4cal  [iden1ficateur]   – Sans  iden4ficateur  un  mutex  par   défaut  est  u4lisé   – Pas  de  barrière  implicite   • #pragma  atomic   – Remplacé  au  besoin  par  un  cri4cal       #pragma  omp  parallel  for  collapse(2)              for  (i  =  0;  i  <  2000;  i++)                for  (j  =  0;  j  <  2000;  j++)   #pragma  omp  atomic                      x++;         Nb   threads   criTcal   atomic   sans   openMP   0,018   0,018   1   0,2   0,15   2   1,7   0,7   3   2,4   0,9   6   6   1,2   12   12   1,2   24   24   1,2   48   47   1,2  
  • 33.
    Paralléliser  le  jeu  de  la  vie     #pragma  omp  parallel  shared(nb_cellules)  private(in,out)   for(etape  =  0;  etape  <  ETAPE;  etape++)   {    in  =  1-­‐in;    out  =  1  -­‐  out;      nb_cellules  =  0;   #pragma  omp  for  collapse(2)  reducTon(+:nb_cellules)        for(i=1;  i  <  DIM-­‐1;  i++)          for(j=1;  j  <  DIM-­‐1;  i++)          {        T[out][i][j]  =f(T[in][i][j],  T[in][i-­‐1][j],  ...)            if  (T[out][i][j]  >  0)            nb_cellules++;            }   #pragma  omp  single                prin[("%d  =>  %d",  etape,  nb_cellules);     }  
  • 34.
    Paralléliser  le  jeu  de  la  vie     #pragma  omp  parallel  shared(nb_cellules)  private(in,out)   for(etape  =  0;  etape  <  ETAPE;  etape++)   {    in  =  1-­‐in;  out  =  1  –  out;  nb_cellules1  =  0;  nb_cellules2  =  0;   #pragma  omp  for  collapse(2)  reducTon(+:nb_cellules1,nb_cellules2)        for(i=1;  i  <  DIM-­‐1;  i++)          for(j=1;  j  <  DIM-­‐1;  i++)  {        if(etape%2)          T[out][i][j]  =f(T[in][i][j],  T[in][i-­‐1][j],  ...)              if  (T[out][i][j]  >  0)            nb_cellules1++;          else  …          }   #pragma  omp  single  nowait    if(etape  %  2)  {                    prin[("%d  =>  %d",  etape,  nb_cellules1);                    nb_cellules1=0;    }  else  {  ….     }  
  • 35.
    OpenMP  détails   sec4ons   #pragma  omp  sec4ons   {      #pragma  omp  sec4on              {                ...              }                #pragma  omp  sec4on              {              ...              }   }   #pragma  omp  for  schedule  (dynamic)   for(i  =  0;  i  <  =  S;  i++)      switch(i)              {    case  0:  …  ;  break  ;    case  1:  …  ;  break  ;    …    case  S:  …  ;  break  ;    default  :  abort();                }   }  
  • 36.
    OpenMP  détails   •    clause  nowait   – Supprime  la  barrière  par  défaut   • for,  single,  sec4on,…   – La  mémoire  n’est  plus  «  synchronisée  »  à  la  fin  de   la  construc4on   • #pragma  omp  flush()  
  • 37.
    Parallélisme  imbriqué   •Imbriquer  des  équipes  de  threads     #omp  parallel  num_threads(externe)   {     //  distribu4ons  des  zones  de  travail       #omp  parallel  for  num_threads(interne)      {      //  parallélisa4on  du  travail  au  sein  d’une  zone        }      
  • 38.
    Parallélisme  imbriqué     • Exprimer  plus  de  parallélisme   – Adapter  le  parallélisme  au  problème   – Méthode  récursive  «  diviser  pour  régner  »   • Difficultés:   – Surcoût  à  la  créa4on  lié  à  la  créa4on  /  d’équipe   – Stabilité  d’exécu4on  (support  d’exécu4on,   ordonnanceur  du  système)   – Qualité  du  par4onnement  des  threads  
  • 39.
    Parallélisme  imbriqué     Qualité  du  support  d’exécu4on   GOMP  3   ICC   Forest   atomic   0,52   0,87   0,49   barrier   75,51   26,98   27,56   cri4cal   12,90   39,01   4,13   for   80,44   28,17   27,33   lock   4,69   4,41   4,06   parallel   3209,75   304,94   171,66   parallel  for   3222,49   311,58   170,56   reduc4on   3220,41   454,20   171,58   Benchmark Nested-EPCC : surcout (µs) de l’invocation des mot-clés OpenMP en contexte de parallélisme imbriqué, sur une machine à 16 coeurs
  • 40.
    Parallélisme  imbriqué    le  benchmark  BT-­‐MZ   } Parallélisa4on  à  deux  niveaux   } Plusieurs  simula4ons  sur  des  zones   différentes   } Plusieurs  threads  pour  traiter   chacune  des  zones   } Imbrica4on  de  régions  parallèles   OpenMP   } Alloca4on  mémoire:  first-­‐touch     } Parallélisme externe irrégulier } Différentes charges de travail selon les zones } Parallélisme interne régulier } Les threads d’une même zone ont la même quantité de travail à effectuer 2  zones  traitées  en   parallèle   4  threads  par  zone   Arbre  de  threads  obtenu  lors  d’une   exécu1on  «  2x4  »  du  benchmark  BT-­‐MZ  
  • 41.
    BT-­‐MZ:  Résultats  expérimentaux   Outer     x  Inner   GOMP  3   Intel   Cache   Original   Info  de  charge   4  x  4   9.4   13.8   14.1   14.1   16  x  1   14.1   13.9   14.1   14.1   16  x  4   11.6   6.1   14.1   14.9   16  x  8   11.5   4.0   14.4   15.0   32  x  1   12.6   10.3   13.5   13.8   32  x  4   11.2   3.4   14.3   14.8   32  x  8   10.9   2.8   14.5   14.7   Accélérations obtenues sur la machine Kwak avec la classe C du benchmark BT-MZ
  • 42.
    Parallélisme  imbriqué   Diviser  pour  régner   • Extraire  beaucoup  de  parallélisme   • Pouvoir  traiter  des  pb  irréguliers     void  fun  (  int  p)   {    #pragma  omp  parallel  for      for(i  …)      …      fun(p+1)  ;       }  
  • 43.
    Parallélisme  imbriqué   Diviser  pour  régner   • Extraire  beaucoup  de  parallélisme   • Pouvoir  traiter  des  pb  irréguliers     void  fun  (  int  p)   {    #pragma  omp  parallel  for  if  (p  <  PROFMAX)    for(i  …)      …      fun(p+1)  ;       }  
  • 44.
    Qsort   hRp://wikis.sun.com/display/openmp     void  quick_sort  (int  p,  int  r,  float  *data)   {          if  (p  <  r)  {                          int  q  =  par44on  (p,  r,  data);                          #pragma  omp  parallel  sec4ons  firstprivate(data,  p,  q,  r)                          {                                  #pragma  omp  sec4on                                  quick_sort  (p,  q-­‐1,  data,  low_limit);                                  #pragma  omp  sec4on                                  quick_sort  (q+1,  r,  data,  low_limit);                          }                  }          }   }  
  • 45.
    Parallélisme  imbriqué   Diviser  pour  régner   Ordonnancement  de  l’applica4on  MPU   – Objec4f  :  trouver  une  fonc4on  mathéma4que   approximant  la  surface  d’un  objet  défini  par  un   nuage  de  points  
  • 46.
    Exécu4on  avec  Cache   } Distribu4on  gloutonne    
  • 47.
  • 48.
    Exécu4on  avec  Cache   OK  !   OK  !  
  • 49.
    Exécu4on  avec  Cache   OK  !   OK  !  
  • 50.
    Exécu4on  avec  Cache   OK  !   OK  !   } Vol  de  travail  de  proche  en  proche  pour  rééquilibrer  la   charge  
  • 51.
    Exécu4on  avec  Cache   OK  !   OK  !   } Vol  de  travail  de  proche  en  proche  pour  rééquilibrer  la   charge  
  • 52.
    Exécu4on  avec  Cache   OK  !   OK  !  
  • 53.
    MPU  :  Accéléra4on  sur  16  cœurs   1 3 5 7 9 11 13 15 2 4 8 16 Nombre de coeurs Accélération libGOMP Null Cache ICC } Exécu4on  sur  un  nuage  de  437644  points   } 101185  créa4ons  de  threads   } Profondeur  maximale  de  récursion  :  15