U TILISATION DE LA M ETHODE DE NUM ´ EROTATION ROUGE ´ -

-NOIR

Dans cette section, nous pr ´esentons quelques solutions pour r ´eduire le temps d’ex ´ecution et le nombre de relaxations de la m ´ethode parall `ele Richardson projet ´ee sur les grappes GPU. Pour cela, nous utilisons la m ´ethode de num ´erotation rouge-noir pour acc ´el ´erer la convergence de cette m ´ethode.

4.5.1/ MISE ŒUVRE SUR UNE GRAPPE GPU

Soit t la somme des trois coordonn ´ees naturelles x, y et z d’un ´el ´ement de vecteur sur un domaine tridimensionnel : t = x + y + z. Comme le montre la figure 4.9-(a), la m ´ethode de num ´erotation rouge-noir consiste `a calculer en parall `ele, `a chaque it ´eration, d’abord les ´el ´ements de vecteur rouges ayant une valeur t paire en fonction de ceux qui sont en noir puis, les ´el ´ements de vecteur noirs ayant une valeur t impaire en fonction de ceux qui sont en rouge. Les it ´erations de ce processus s’arr ˆetent lorsque la convergence est atteinte.

La m ´ethode de num ´erotation rouge-noir peut ˆetre mise en œuvre sur le GPU de deux fac¸ons :

– Parmi tous les threads ex ´ecut ´es, un seul thread sur deux calcule son ´el ´ement de vecteur rouge ou noir `a la fois ou,

– tous les threads ex ´ecut ´es calculent d’abord les ´el ´ements de vecteur en rouge puis ceux en noir.

Cependant dans les deux mises en œuvre, pour chaque transaction m ´emoire effectu ´ee par un demi-warp, seule la moiti ´e du segment m ´emoire requis est utilis ´ee. Donc, le calcul

z x y z x y

(a) Num ´erotation rouge-noir sur (b) Num ´erotation rouge-noir sur

les axes x, y et z l’axe y

FIGURE 4.9 – Num ´erotation rouge-noir pour le calcul des ´el ´ements de vecteur dans un domaine tridimensionnel

de tous les ´el ´ements de vecteur rouges et noirs n ´ecessite deux fois le nombre de tran-sactions m ´emoires initial. Par cons ´equent, nous proposons d’appliquer la num ´erotation rouge-noir, seulement, sur l’axe y comme le montre la figure 4.9-(b). En effet, dans ce cas, cette m ´ethode permet de calculer en parall `ele d’abord les ´el ´ements de vecteur rouges ayant une coordonn ´ee y paire, en fonction des ´el ´ements de vecteur noirs ayant une coor-donn ´ee y impaire, puis vice versa.

En outre, dans la mise en œuvre de la m ´ethode Richardson projet ´ee sur un GPU pro-pos ´ee dans la section 4.3, un probl `eme de l’obstacle de taille (nx × ny × nz) est d ´ecompro-pos ´e en nz grilles de taille nx × ny. Puis, chaque kernel de la m ´ethode est ex ´ecut ´e en parall `ele par nx × ny threads, de sorte que chaque thread soit en charge de nz ´el ´ements de vecteur le long de l’axe z (un ´el ´ement de chaque grille du probl `eme). Donc, nous exploitons cette propri ´et ´e de mise en œuvre dans la fonction de mise `a jour des ´el ´ements du vecteur it ´er ´e. En effet, le calcul des nouvelles valeurs des ´el ´ements de vecteur dans la grille i utilise celles des ´el ´ements de vecteur calcul ´ees dans la grille i − 1. La figure 4.10 d ´ecrit les nouvelles mises en œuvre des kernels du solveur Richardson projet ´ee, bas ´ees sur la m ´ethode de num ´erotation rouge-noir.

Enfin, les architectures mat ´erielle et logicielle des GPUs de la grappe de calcul per-mettent d’effectuer des ex ´ecutions simultan ´ees entre les fonctions CPU et les kernels GPU. En fait, le lancement d’une ex ´ecution de kernel dans un programme CPU est asyn-chrone (lorsque cette variable d’environnement n’est pas d ´esactiv ´ee dans le GPU). Ceci signifie que le contr ˆole d’ex ´ecution est rendu au processus CPU avant que l’ex ´ecution du kernel par le GPU soit termin ´ee (voir [28]). Nous utilisons cette propri ´et ´e des GPUs pour am ´eliorer la mise en œuvre parall `ele de la fonction Calculer Nouveaux Elements Vecteur() (pr ´esent ´ee dans la section 4.3.2). Par cons ´equent, chaque nœud de la grappe proc `ede d’abord au calcul des ´el ´ements de vecteur locaux, u(x, y, z) o `u 0 < y < ny−1 et 0 < z < nz−1, en ex ´ecutant les nouveaux kernels bas ´es sur la m ´ethode de num ´erotation rouge-noir (voir figure 4.10). Puis, il effectue des ´echanges de donn ´ees (valeurs des points associ ´es aux fronti `eres) avec les nœuds voisins. Enfin, il calcule les nouvelles valeurs des ´el ´ements de vecteur associ ´es aux fronti `eres du sous-probl `eme local. Dans ce cas, les calculs des

/* Kernel de la multiplication matrice-vecteur */

__global__ void Multiplication_MV(..., double* U, double* Y) {

//Charger dans des registres les coefficients de la matrice: //centre, ouest, est et avant

...

for(int tz=0; tz<nz; tz++){

if((tx<nx) && (ty<ny) && (tid<n)){

double sum = centre * fetch_double(U, tid);

if(tx != 0) sum += ouest * fetch_double(U, tid-1); if(tx != nx-1) sum += est * fetch_double(U, tid+1); if(tz != nz-1) sum += avant * fetch_double(U, tid+nx*ny); Y[tid] = sum;

}

tid += pas; }

}

/* Kernel de mise `a jour */

__global__ void Mise_A_Jour_Vecteur(..., int rn, double* G, double* Y, double* U) {

//Charger dans des registres le coefficient de la matrice: //centre, sud, nord, arriere

double valeur = 0.0; ...

for(int tz=0; tz<nz; tz++){

if((tx<nx) && (ty<ny) && (tid<n) && ((ty&1)==rn)){

double var = G[tid] - Y[tid] - sud * fetch_double(U, tid-nx) - nord * fetch_double(U, tid+nx);

if(tz != 0) var -= avant * valeur; //utiliser l’´el´ement de la grille pr´ec´edente var = (var / centre) + fetch_double(U, tid);

if(var < 0) var = 0; //projection U[tid] = valeur = var;

}

tid += pas; }

}

/* Fonction CPU*/

void Calculer_Nouveaux_Elements_Vecteur(double* A, double* G, double* U) {

double *Y;

int rouge=0; int noir=1;

//Configurer l’ex´ecution des kernels: Grille et Bloc //Charger le vecteur U dans la m´emoire texture //Allouer un espace m´emoire GPU pour le vecteur Y Multiplication_MV<<<Grille,Bloc>>>(..., U, Y);

Mise_A_Jour_Vecteur<<<Grille,Bloc>>>(..., rouge, G, Y, U); Mise_A_Jour_Vecteur<<<Grille,Bloc>>>(..., noir, G, Y, U); }

FIGURE4.10 – Kernels GPU modifi ´es du solveur Richardson projet ´ee

´el ´ements de vecteur locaux par les GPUs de la grappe sont effectu ´es en parall `ele avec les ´echanges de donn ´ees entre les CPUs.

4.5.2/ EXPERIMENTATIONS´

Le tableau 4.4 illustre les temps d’ex ´ecution en secondes et le nombre de relaxations effectu ´ees sur une grappe de 12 GPUs, par les algorithmes synchrone et asynchrone de la m ´ethode Richardson projet ´ee utilisant la num ´erotation rouge-noir. De plus, il pr ´esente les nouvelles valeurs du ratio τmax d ´efini ici comme : le rapport entre le temps d’ex ´ecution de la m ´ethode de relaxation par blocs sur 24 cœurs CPU et celui de la m ´ethode de Richardson projet ´ee utilisant la num ´erotation rouge-noir sur 12 GPUs.

M ´ethode Taille du pb. ^{Synchrone Asynchrone}

T empsgpu # relax. τmax T empsgpu # relax. τmax

Rouge-noir

256³ 18, 37 71.988 7, 48 12, 58 67.638 10, 47

512³ 349, 23 271.188 13, 79 289, 41 246.036 15, 10 768³ 2.773, 65 590.652 14, 87 2.222, 22 532.806 16, 73 800³ 2.748, 23 638.916 15, 87 2.502, 61 592.525 15, 75 TABLE 4.4 – Temps d’ex ´ecution en secondes du solveur parall `ele Richardson projet ´ee utilisant la num ´erotation rouge-noir sur une grappe de 12 GPUs

Nous pouvons remarquer que la m ´ethode de num ´erotation rouge-noir permet au sol-veur Richardson projet ´e, synchrone et asynchrone, de r ´eduire le nombre de relaxations par rapport `a celui donn ´e dans le tableau 4.2. Ceci signifie que le solveur Richardson pro-jet ´e converge plus rapidement en utilisant la m ´ethode de num ´erotation rouge-noir pour la mise `a jour du vecteur it ´er ´e. En effet, cette m ´ethode lui permet d’utiliser les valeurs des ´el ´ements de vecteur rouges r ´ecemment calcul ´ees pour mettre `a jour celles des ´el ´ements de vecteur noirs. Par cons ´equent, nous pouvons remarquer que les temps d’ex ´ecution du solveur Richardson projet ´e pr ´esent ´es dans le tableau 4.4 sont diminu ´es, en moyenne, de 32% par rapport `a ceux pr ´esent ´es dans le tableau 4.2. Bien ´evidemment, les ratios τ_max sont aussi sensiblement meilleurs, compar ´es `a ceux pr ´esent ´es dans le tableau 4.2. Ils montrent que la r ´esolution des probl `emes de l’obstacle avec la m ´ethode Richardson projet ´ee mise en œuvre sur la grappe GPU est jusqu’ `a 16 fois plus rapide (dans ces exemples) qu’avec la m ´ethode de relaxation par blocs mise en œuvre sur la grappe CPU. La figure 4.11 illustre le passage `a l’ ´echelle faible des algorithmes parall `eles, syn-chrone et asynsyn-chrone, de la m ´ethode Richardson projet ´ee utilisant la technique de num ´erotation rouge-noir. Les tests exp ´erimentaux sont r ´ealis ´es sur une grappe de dix GPUs Tesla. Nous avons fix ´e la taille d’un sous-probl `eme `a 2563 par nœud GPU (un cœur CPU et un GPU). Dans la figure 4.11, nous pr ´esentons le nombre de relaxations par seconde effectu ´ees, en moyenne, par un nœud GPU. Nous pouvons remarquer que l’efficacit ´e de l’algorithme asynchrone est plus ou moins stable, tandis que celle de l’al-gorithme synchrone diminue (jusqu’ `a 81% dans cet exemple) avec l’augmentation du nombre de nœuds GPU sur la grappe. Ceci est d ˆu au fait que l’utilisation des GPUs permet de r ´eduire le rapport entre le temps de calcul et celui de communications. En effet, la puissance de calcul des GPUs permet d’acc ´el ´erer les calculs, ainsi de r ´eduire les temps de calcul, alors que les temps de communications restent inchang ´es et de-viennent importants. Dans ce contexte, les algorithmes asynchrones supportent mieux le passage `a l’ ´echelle que leurs homologues synchrones. Dans le cas des grappes GPU `a grande ´echelle ou g ´eographiquement distantes, les algorithmes synchrones peuvent ˆetre p ´enalis ´es par les communications. C’est pourquoi nous pensons que les algorithmes asynchrones seraient d’autant plus int ´eressants dans ce type de plateformes de calcul

30 35 40 45 50 55 0 1 2 4 6 8 10

Nombre de relaxation par seconde

Nombre de GPUs 80.81% 84.05% 85.30% 88.33% 95.92% 100% 96.90% 98.13% 98.13% 98.28% 100% 100% 80.81% 84.05% 85.30% 88.33% 95.92% ^96.90% 98.13% 98.13% 98.28% 100% 100% 80.81% 84.05% 85.30% 88.33% 95.92% ^96.90% 98.13% 98.13% 98.28% 100% 100% 80.81% 84.05% 85.30% 88.33% 95.92% ^96.90% 80.81% 84.05% 85.30% 88.33% 95.92% ^96.90% 98.13% 98.13% 98.28% 100% 100% 80.81% 84.05% 85.30% 88.33% 95.92% ^96.90% 98.13% 98.13% 98.28% 100% 100% "Synchrone" "Asynchrone"

FIGURE4.11 – Passage `a l’ ´echelle des algorithmes parall `eles synchrone et asynchrone de la m ´ethode Richardson rouge-noir projet ´ee

pour am ´eliorer les temps d’ex ´ecution des m ´ethodes it ´eratives parall `eles.

4.6/ C

Dans ce chapitre, nous avons pour objectif d’exploiter la puissance de calcul d’une grappe GPU pour la r ´esolution des probl `emes de l’obstacle de grandes tailles qui inter-viennent, par exemple, dans la physique ou les math ´ematiques des finances. Pour cela, nous avons utilis ´e deux m ´ethodes it ´eratives, `a savoir : la m ´ethode Richardson projet ´ee et celle de relaxation par blocs projet ´ee, pour la r ´esolution des syst `emes non lin ´eaires issus de la discr ´etisation spatiale d’un probl `eme de l’obstacle.

Vu les grandes tailles des probl `emes `a r ´esoudre, nous nous sommes int ´eress ´es, plus particuli `erement, aux algorithmes parall `eles synchrones et asynchrones des deux m ´ethodes it ´eratives sur une grappe GPU. Toutefois, leurs mises en œuvre diff `erent dans la fac¸on dont les ´el ´ements du vecteur it ´er ´e sont calcul ´es. En effet, le solveur Richardson projet ´e est bas ´e sur les it ´erations par points de la m ´ethode Jacobi, tandis que celui de relaxation par blocs projet ´e est bas ´e sur les it ´erations par blocs de la m ´ethode Gauss-Seidel. A cet effet, nous avons remarqu ´e que le solveur Richardson projet ´e est, large-ment, plus performant que celui de relaxation par blocs projet ´e sur une grappe GPU, m ˆeme s’il effectue plus de relaxations que ce dernier pour atteindre la convergence.

Par cons ´equent, nous pouvons conclure que les meilleures m ´ethodes de r ´esolution d ´evelopp ´ees pour les grappes CPU ne sont pas forc ´ement adapt ´ees aux grappes GPU, car sur la grappe CPU de tests le solveur de relaxation par blocs projet ´e a ´et ´e plus performant que celui de Richardson projet ´e. En effet, les it ´erations par blocs et les mises `a jour de la m ´ethode Gauss-Seidel assurent aux solveurs it ´eratifs une convergence rapide sur une grappe CPU mais elles sont difficiles `a mettre en œuvre sur des GPUs. Par contre, les it ´erations par points et les mises `a jour de la m ´ethode Jacobi permettent de

bien exploiter les ressources GPUs et, ainsi, une r ´esolution rapide des probl `emes de l’obstacle sur une grappe GPU, m ˆeme si leur taux de convergence est faible par rapport

`a celui des it ´erations Gauss-Seidel par blocs.

Ensuite, nous avons utilis ´e une technique de num ´erotation rouge-noir dans la mise en œuvre des algorithmes synchrone et asynchrone de la m ´ethode Richardson projet ´ee sur une grappe GPU. Cette technique permet `a ces solveurs parall `eles de r ´eduire le nombre de relaxations n ´ecessaires pour atteindre la convergence et, ainsi, d’acc ´el ´erer leurs ex ´ecutions sur une grappe GPU. En fait, elle est appliqu ´ee au processus de mise `a jour du vecteur it ´er ´e de telle fac¸on qu’ `a chaque it ´eration, les valeurs des ´el ´ements de vec-teur rouges r ´ecemment calcul ´ees sont utilis ´ees pour mettre `a jour celles des ´el ´ements de vecteur noirs puis vice-versa. Par cons ´equent, nous avons remarqu ´e que l’utilisation de cette technique de mise `a jour a permis aux solveurs parall `eles de la m ´ethode Richard-son projet ´ee d’am ´eliorer leurs temps d’ex ´ecution en moyenne de 32% sur une grappe de 12GPUs ce qui n’est pas n ´egligeable.

Enfin, les tests d’exp ´erimentation, effectu ´es sur les deux grappes CPU et GPU, ont montr ´e que les algorithmes parall `eles asynchrones des deux m ´ethodes sont plus per-formants que leurs homologues synchrones. Plus pr ´ecis ´ement, nous avons montr ´e que l’utilisation des GPUs permet de r ´eduire le ratio entre le temps de calcul et celui de com-munications. Ceci gr ˆace `a la puissance de calcul des GPUs qui permet de r ´eduire les temps de calcul. N ´eanmoins, cette performance n’est pas si ´evidente car la grappe de tests utilis ´ee est compos ´ee de nœuds de calcul homog `enes interconnect ´es par des liens de communication `a faible latence. Par ailleurs, les algorithmes asynchrones seraient plus performants sur des grappes g ´eographiquement distantes et `a ressources h ´et ´erog `enes.

5