Recouvrement calcul – communication avec OpenMP

Le recouvrement calcul – communication repose sur l’exécution simultanée de calculs par les processeurs et de communications par les cartes réseau. Pour ce faire, l’existence de primitives de communications non bloquantes et asynchrones facilite l’implémentation. Le caractère non bloquant permet que les processus ne restent pas dans la primitive jusqu’à la terminaison de la communication. Le caractère asynchrone permet que la communication s’étale dans le temps entre son lancement et la vérification de sa terminaison et qu’elle ne s’effectue pas uniquement lors de la vérification. Une étude des schémas de recouvrement calcul – communication peut être trouvée dans [22, 24] ainsi que des suggestions pour les différents paramètres d’optimisation.

3.2. Optimisation de l’opérateur de gyromoyenne distribuée 55

0 20 40 60 80 100

2x2 2x4 4x4 4x8 8x8

Percentage of total execution time

allocations preprocessgyroaverage postprocesscommunicationsdeallocations

Figure3.7 – Pourcentage du temps moyen d’exécution des différentes parties du diagnostic moments fluides avec gyromoyenne distribuée pour un maillage512×512×128×64 sur différentes distributions de processus enr×θ avec 8threads par processus MPI.

Gyromoyenne distribuée avec recouvrement

Appliqué à la gyromoyenne distribuée, le recouvrement s’appuiera sur le traitement par blocs explicité auparavant. Le principe est d’entamer les communications des halos du bloc suivant tout en effectuant le calcul de la gyromoyenne pour le bloc actuel. Il serait possible d’effectuer simultanément les communications sur plus de blocs mais nous nous limiterons à deux blocs en parallèle – un en cours de traitement et un en cours d’échange de halos. Le déroulement de l’opérateur avec recouvrement est détaillé par l’algorithme 6. Tout d’abord, deux variablesf_block1 etf_block2 sont désormais utilisées pour contenir les deux blocs. Il est nécessaire de commencer par lancer l’échange des deux premiers blocs afin de démarrer le pipeline calcul – communication. L’étape 1 permet d’initialiser les buffers et de lancer l’échange de halos (2) pour les blocs 0 à N_block−1 dans les boucles indicées 0 à Nblock−1. La phase 3 vérifie la terminaison de l’échange de halo (phase 4), toujours pour les blocs de 0 à Nblock−1, mais dans les boucles indicées de 1 à Nblock. L’étape 5 inverse les références des variables vers les blocs. Ainsi, au tour de boucle 0, le bloc 0 est initialisé dansfblock1 et son échange de halos débute. Ensuite, les références sont inversées et le bloc 0 est désormais référencé parf_block2. Au tour de boucle 1, le bloc 1 est initialisé dans f_block1 et son échange de halo débute. Puis, la terminaison de l’échange de halo du bloc 0 est vérifiée dans f_block2 et les traitements sont exécutés. Finalement, les références sont de nouveau inversées et ainsi de suite jusqu’à la dernière boucle où seuls la réception et les traitements du dernier bloc sont effectués.

Étude des capacités du recouvrement

Avec l’algorithme donné en 3.2.2, il est possible d’estimer le gain que de performance que le recouvrement peut apporter. Nous présenterons pour cela une version simplifiée du

56 3.2. Optimisation de l’opérateur de gyromoyenne distribuée Algorithme 6 :Diagnostic avec gyromoyenne distribuée et recouvrement.

Entrées:f,b_s

Sorties :J.f,Mfluid

pouri_block : 0→N_block faire

1 sii_block 6=N_block alors

pouri: 0→bs−1 faireen parallèle OpenMP i_ϕ = (iblock×b_s+i) modN_ϕ

i_v = (i_block×b_s+i)÷N_ϕ

fblock1(i)← preprocess(f(r_l :ru, θ_l:θu, ϕiϕ, v_kiv, µ))

2 start_send_receive_halos(f_block1)

3 sii_block 6= 0 alors

4 terminate_send_receive_halos(f_block2) pouri: 0→bs−1 faireen parallèle OpenMP

i_ϕ = ((iblock−1)×b_s+i) mod N_ϕ i_v = ((i_block−1)×b_s+i)÷N_ϕ gyroaverage(fblock2(i))

Mfluid← postprocess(f_block2(i)) f(r_l:r_u, θ_l:θ_u, ϕ_iϕ, v_kiv, µ)←f_block2

5 swap(f_block1,f_block2)

raisonnement détaillé dans [60]. Dans l’étude des temps d’exécution, nous ne considére-rons que deux phases : la phase de communication qui inclut l’étape d’initialisation des blocs et l’étape de communication, et la phase de calcul qui inclut l’étape de calcul de la gyromoyenne et l’étape de post-traitement.

NotonsTcommetTcalcles temps d’exécution d’un échange de halo et du calcul de la gy-romoyenne sur un sous-domaine. Notons égalementα= ^T_T^comm

calc le ratio entre les deux temps d’exécution et Toverlap le temps d’exécution total du diagnostic utilisant la gyromoyenne distribuée avec recouvrement. Plusieurs cas de figure pour le déroulement du recouvrement peuvent se présenter en fonction du rapportαtel que le montre la Figure 3.8. Si les temps d’exécution de la phase de communication et de la phase de calcul sont identiques (α= 1), alors le recouvrement est parfait ; il n’y a pas de temps d’attente et le temps d’exécution est minimal. Néanmoins, si le rapport se déséquilibre (α <1etα >1), une partie du ma-tériel est en attente durant le déroulement de certaines sections de l’opérateur et le temps d’exécution n’est plus optimal. À noter que ce temps d’exécution est toujours meilleur que celui de l’opérateur sans recouvrement (dans la figure tous les segments seraient mis bout à bout).

Notons Tdistrib le temps d’exécution du diagnostic utilisant la gyromoyenne avec blocs sans recouvrement. Il est possible d’exprimer les temps total d’exécution grâce aux formules suivantes :

Toverlap=Nblock·max(Tcomm,Tcalc) +min(Tcomm,Tcalc) Tdistrib=Nblock×(Tcomm+Tcalc).

3.2. Optimisation de l’opérateur de gyromoyenne distribuée 57

Figure 3.8 – Diagramme de Gantt du déroulement de blocs de communications et de calculs pour différents rapports de temps d’exécutionα dans le cas d’un recouvrement.

L’accélération offerte par le recouvrement calcul – communication peut alors s’écrire Tdistrib

oùδ dépend du ratio temps de communication sur temps de calcul et est défini par

δ =

L’équation (3.5) peut être représentée graphiquement en fonction des paramètres α et Nblock par la Figure 3.9. On observe dans un premier temps que l’accélération qui peut être espérée du recouvrement décroît rapidement avec la divergence des temps de communication et de calcul. On observe également que l’accélération maximale de 2 est obtenue pour un ratio α = 1 et que celle-ci tend vers deux avec le nombre de blocs. Cela confirme ce qui pouvait être déduit de la Figure 3.8 et permet d’avoir une estimation grossière du gain apporté par le recouvrement.

Si l’on se réfère à l’équation (1.6) (section 1.2.3), le temps d’exécution de l’échange de halos peut être écrit Tcomm =λ+b_sτinit+β b_sN_H avec b_s le nombre de plans par bloc, τ_init le temps d’initialisation d’un bloc et N_H la taille d’un halo. Le temps d’exécution du calcul de la gyromoyenne peut également être écrit Tcomp=γ b_s+τextract avec τextract

le temps d’exécution de l’extraction des moments fluide pour un bloc. La taille de bloc optimale peut alors être déduite analytiquement mais nécessite une connaissance fine des performances de l’algorithme (γ) et de l’architecture du réseau (λetβ). L’impact des effets de localité mémoire est également à prendre en compte. Cette analyse ne sera pas conduite ici, mais le lecteur peut trouver une étude similaire dans [23].

Implémentation du recouvrement

L’implémentation de l’algorithme de recouvrement nécessite l’utilisation de commu-nication MPI pouvant s’effectuer en tâche de fond durant les calculs. Les primitives non