Le calcul numérique de haute performance - Université de Laval

Le calcul numérique de haute performance
en astrophysique
Hugo Martel
Université Laval
Québec, 31 août 2007

1) Introduction
Le calcul de haute performance (CHP) s’est développé selon 3 axes:
1) Résolution (nombre de particules N)
2) Précision des algorithmes
3) Détails des processus physiques
précision
P 3 M
PM
Arbre + Quad
512 3
64 3
1000
Arbre
résolution
2048 3
256 3
32 3 (1985)
50
Gravité
Hydrodynamique Transfer radiatif
Réactions
chimiques
Relativité
physique

À partir de quand un calcul devient “haute performance” ?
Réponse: à partir du moment où il est dans notre intérêt
d’optimiser le programme.
Exemple: Supposons qu’en travaillant pendant 1 mois sur
l’optimisation d’un programme, on peut quadrupler sa vitesse
d’exécution.
• Temps d’exécution de une minute: on investi 1 mois de travail
pour sauver 45 secondes: ça ne vaut pas la peine.
• Temps d’exécution de 2 ans: on investi 1 mois de travail pour
sauver 18 mois: ça vaut la peine.
L’optimisation est le concept fondamental du CHP
optimisation performance
Langage de programation: FORTRAN
3 types d’architectures: • Ordinateurs sériels
• Ordinateurs vectoriels
• Ordinateurs parallèles

2) Ordinateurs sériels
Tous les ordinateurs datant d’avant 1980.
Tous les ordinateurs portables.
Toutes les stations de travail.
En gros, tous les ordinateurs qu’on n’appelle pas “superordinateur”.
Ordinateur sériel: Les instructions sont exécutées en série (une à la fois).

Exemple concret: calcul de la correction à courte distance dans l’algorithme P 3 M
�(r) =
Volume cubique contenant N particules.
On identifie les paires de particules séparées
par une courte distance r < 2.8� (particules
voisines).
Pour chaque paire de particules, on calcule
la fonction �(r).
� est la longeur d’adoucissement.
�(224x�224x 3 +70x 4 +48x 5 �21x 6 )/35� 2 , x < 1;
�(12/x 2 �224+896x�840x 2 +224x 3 +70x 4 �48x 5 +7x 6 )/35� 2 , 1 < x < 2;
�1/r 2 , x > 2.
où x = 2r/�

subroutine shortrange(r,pairs,src,npairs,nmax,np)
integer pairs(nmax,2)
dimension src(nmax), r(np,3)
do m=1,npairs
i=pairs(m,1)
j=pairs(m,2)
dx=r(i,1)-r(j,1)
dy=r(i,2)-r(j,2)
dz=r(i,3)-r(j,3)
r2=dx*dx+dy*dy+dz*dz
r=sqrt(r2)
src(m)=CHI(r)
enddo
return
end
*--------------------------------------------------------------function
chi(r)
parameter (epsilon=0.00001)
c1=-1./(35.*epsilon*epsilon)
x=2*r/epsilon
if(x.lt.1.) then
chi=c1*x*(224.+x*x*(-224.+x*(70.+x*(48.-21.*x))))
else if(x.lt.2.) then
chi=c1*(12.+x*x*(-224.+x*(896.+x*(-840.+x*(224.+x*
+ (70.+x*(-48.+7.*x)))))))/x/x
else
chi=-1./r**2
endif
return
end

chi(0:npt)
0
1
2
3
4
5
6
7
8
9
npt
�(0)
�(�r)
�(2�r)
�(3�r)
�(4�r)
�(5�r)
�(6�r)
�(7�r)
�(8�r)
�(9�r)
...
�(npt*�r)
Table d’interpolation pour �(r)
chi(k+1)
chi(k)
�
c = (r � k�r) / �r
� = (1 � c) chi(k) + c chi(k+1)
k�r r (k+1)�r
d = r / �r
k = int(d), c = frac(d)

subroutine shortrange(r,pairs,src,npairs,nmax,np)
parameter (npt=10000)
integer pairs(nmax,2)
dimension src(nmax), r(np,3)
common /short/ chi(0:npt), dr
do m=1,npairs
i=pairs(m,1)
j=pairs(m,2)
dx=r(i,1)-r(j,1)
dy=r(i,2)-r(j,2)
dz=r(i,3)-r(j,3)
r2=dx*dx+dy*dy+dz*dz
r=sqrt(r2)
d=r/dr
k=int(d)
c=d-k
src(m)=(1.-c)*chi(k)+c*chi(k+1)
enddo
return
end
+ + � � �

� = (1 � c) chi(k) + c chi(k+1)
� = chi(k) + c [ chi(k+1) � chi(k) ]
� = chi(k) + c �chi(k)
où: �chi(k) = chi(k+1) � chi(k)
chi(0:npt)
0
1
2
3
4
5
6
7
8
9
npt
�(0)
�(�r)
�(2�r)
�(3�r)
�(4�r)
�(5�r)
�(6�r)
�(7�r)
�(8�r)
�(9�r)
...
�(npt*�r)
0
1
2
3
4
5
6
7
8
9
npt-1
dchi(0:npt-1)
�(�r)��(0)
�(2�r)��(�r)
�(3�r)��(2�r)
�(4�r)��(3�r)
�(5�r)��(4�r)
�(6�r)��(5�r)
�(7�r)-�(6�r)
�(8�r)��(7�r)
�(9�r)��(8�r)
�(10�r)��(9�r)
...
�(npt*�r)-�[(npt-1)*�r]

subroutine shortrange(r,pairs,src,npairs,nmax,np)
parameter (npt=10000)
integer pairs(nmax,2)
dimension src(nmax), r(np,3)
common /short/ chi(0:npt), dchi(0:npt-1), dr
do m=1,npairs
i=pairs(m,1)
j=pairs(m,2)
dx=r(i,1)-r(j,1)
dy=r(i,2)-r(j,2)
dz=r(i,3)-r(j,3)
r2=dx*dx+dy*dy+dz*dz
r=sqrt(r2)
d=r/dr
k=int(d)
c=d-k
src(m)=chi(k)+c*dchi(k)
enddo
return
end
+ + �

subroutine shortrange(r,pairs,src,npairs,nmax,np)
parameter (npt=10000)
integer pairs(nmax,2)
dimension src(nmax), r(np,3)
common /short/ chi(0:npt), dchi(0:npt-1), dr
do m=1,npairs
i=pairs(m,1)
j=pairs(m,2)
dx=r(i,1)-r(j,1)
dy=r(i,2)-r(j,2)
dz=r(i,3)-r(j,3)
r2=dx*dx+dy*dy+dz*dz
r=sqrt(r2)
d=r/dr
k=int(d)
c=d-k
src(m)=chi(k)+c*dchi(k)
enddo
return
end
+ + + +
- � � �
� � � �
/
int()
sqrt()

Une racine carrée est 10 à 20 fois plus
longue à calculer qu’une addition ou une
multiplication.
Solution: considérer la fonction � comme
étant une fonction de r 2 plutôt que r.
On crée de nouvelles tables d’interpolation
dans lesquelles la fonction est évaluée à
des intervalles constants en r 2 .
Nouvel incrément: �r 2
chi(0:npt)
0
1
2
3
4
5
6
7
8
9
npt
�(0)
�(�r 2 )
�(2�r 2 )
�(3�r 2 )
�(4�r 2 )
�(5�r 2 )
�(6�r 2 )
�(7�r 2 )
�(8�r 2 )
�(9�r 2 )
...
�(npt*�r 2 )
0
1
2
3
4
5
6
7
8
9
npt-1
dchi(0:npt-1)
�(�r 2 )��(0)
�(2�r 2 )��(�r 2 )
�(3�r 2 )��(2�r 2 )
�(4�r 2 )��(3�r 2 )
�(5�r 2 )��(4�r 2 )
�(6�r 2 )��(5�r 2 )
�(7�r 2 )-�(6�r 2 )
�(8�r 2 )��(7�r 2 )
�(9�r 2 )��(8�r 2 )
�(10�r 2 )��(9�r 2 )
...
�(npt*�r 2 )-�[(npt-1)*�r 2 ]

subroutine shortrange(r,pairs,src,npairs,nmax,np)
parameter (npt=10000)
integer pairs(nmax,2)
dimension src(nmax), r(np,3)
common /short/ chi(0:npt), dchi(0:npt-1), dr2
do m=1,npairs
i=pairs(m,1)
j=pairs(m,2)
dx=r(i,1)-r(j,1)
dy=r(i,2)-r(j,2)
dz=r(i,3)-r(j,3)
r2=dx*dx+dy*dy+dz*dz
d=r2/dr2
k=int(d)
c=d-k
src(m)=chi(k)+c*dchi(k)
enddo
return
end

Les 4 opérations mathématiques de base (être humain) : + � � /
Les 4 opérations mathématiques de base (ordinateur) : + CS � INV
Soustraction: a � b a + CS(b)
Division: a / b a � INV(b)
Temps de calcul:
Comparable pour + � INV (typically 1 ns)
Beaucoup plus court pour CS (1 bit vs 64 bits).
Comparable pour + � �
2 fois plus long pour /
On a intérêt à éliminer les divisions.

subroutine shortrange(r,pairs,src,npairs,nmax,np)
parameter (npt=10000)
integer pairs(nmax,2)
dimension src(nmax), r(np,3)
common /short/ chi(0:npt), dchi(0:npt-1), dr2
odr2=1./dr2
do m=1,npairs
i=pairs(m,1)
j=pairs(m,2)
dx=r(i,1)-r(j,1)
dy=r(i,2)-r(j,2)
dz=r(i,3)-r(j,3)
r2=dx*dx+dy*dy+dz*dz
d=r2*odr2
k=int(d)
c=d-k
src(m)=chi(k)+c*dchi(k)
enddo
return
end

subroutine shortrange(r,pairs,src,npairs,nmax,np)
parameter (npt=10000)
integer pairs(nmax,2)
dimension src(nmax), r(np,3)
common /short/ chi(0:npt), dchi(0:npt-1), dr2
odr2=1./dr2
do m=1,npairs
i=pairs(m,1)
j=pairs(m,2)
dx=r(i,1)-r(j,1)
dy=r(i,2)-r(j,2)
dz=r(i,3)-r(j,3)
r2=dx*dx+dy*dy+dz*dz
d=r2*odr2
k=int(d)
c=d-k
src(m)=chi(k)+c*dchi(k)
enddo
return
end
Alternative
dx2=dx*dx
dy2=dy*dy
dz2=dz*dz
r2=dx2+dy2+dz2
Très mauvaise idée!
Raison: existence
des MADD’s

MADD’s : “Multiply - Add’s”
(a+b)*c Addition: 1 ns
Multiplication: 1 ns
Temps total: 2 ns 1.1 ns
0
1
0
1
1
0
1
1
0
1
0
0
1
1
0
0
0
0
1
1
0
0
1
0
1
1
0
0
1
0
1
1
1
0
1
1
0
0
1
1
0
1
0
0
0
1
0
1
1
0
1
0
0
0
1
0
1
0
0
0
0
0
1
1
1
1
0
0
1
1
0
1
0
1
0
0
1
1
0
1
1
0
1
0
1
0
1
0
0
1
1
1
0
1
1
1
0
0
1
1
0
1
1
1
0
1
0
1
1
0
0
0
0
1
1
0
1
1
0
0
1
1
1
0
0
1
1
0
1
1
0
1
1
0
0
0
1
0
1
1
0
0
1
0
1
1
0
1
0
0
0
1
0
1
1
0
0
1
0
1
1
0
0
0
1
0
0
1
0
0
1
1
0
1
1
0
0
1
0
1
1
0
1
0
1
0
1
1
0
0
0
1
a
b
a+b
c
(a+b)*c

MADD’s : “Multiply - Add’s”
0
1
0
1
1
0
1
1
0
1
0
0
1
1
0
0
0
0
1
1
0
0
1
0
1
1
0
0
1
0
1
1
1
0
1
1
0
0
1
1
0
1
0
0
0
1
0
1
1
0
1
0
0
0
1
0
1
0
0
0
0
0
1
1
1
1
0
0
1
1
0
1
0
1
0
0
1
1
0
1
1
0
1
0
1
0
1
0
0
1
1
1
0
1
1
1
0
0
1
1
0
1
1
1
0
1
0
1
1
0
0
0
0
1
1
0
1
1
0
0
1
1
1
0
0
1
1
0
1
0
1
1
1
1
0
1
1
0
0
0
1
0
1
1
0
0
1
0
1
1
0
1
0
0
0
1
0
1
1
0
0
1
0
1
1
0
0
0
1
0
0
1
0
0
1
1
0
1
1
0
0
1
0
1
1
0
1
0
1
0
1
1
0
0
0
1
a
b
a+b
c
(a+b)*c
L’addition commence

MADD’s : “Multiply - Add’s”
0
1
0
1
1
0
1
1
0
1
0
0
1
1
0
0
0
0
1
1
0
0
1
0
1
1
0
0
1
0
1
1
1
0
1
1
0
0
1
1
0
1
0
0
0
1
0
1
1
0
1
0
0
0
1
0
1
0
0
0
0
0
1
1
1
1
0
0
1
1
0
1
0
1
0
0
1
1
0
1
1
0
1
0
1
0
1
0
0
1
1
1
0
1
1
1
0
0
1
1
0
1
1
1
0
1
0
1
1
0
0
0
0
1
1
0
1
1
0
0
1
1
1
0
0
1
1
0
1
0
1
1
0
0
0
1
1
1
0
1
1
0
0
0
1
0
1
1
0
0
1
0
1
1
0
1
0
0
0
1
0
1
1
0
0
1
0
1
1
0
0
0
1
0
0
1
0
0
1
1
0
1
1
0
0
1
0
1
1
0
1
0
1
0
1
1
0
0
0
1
1
1
0
1
a
b
a+b
c
(a+b)*c
La multiplication commence,
l’addition continue

Boucles multiples
Optimisation: A) Remonter vers les boucles extérieures
B) Ordre des boucles

A) Remonter vers les boucles extérieures
Dans le cas de boucles multiples, le gros du travail
est effectué par la boucle intérieure
C’est la boucle intérieure qu’il faut optimiser
parameter (n=128)
dimension a(n), b(n), c(n)
dimension x(n**3)
index=0
do i=1,n
do j=1,n
do k=1,n
index=index+1
x(index)=a(i)*a(i)+b(j)*b(j)+c(k)*c(k)
enddo
enddo
enddo
parameter (n=128)
dimension a(n), b(n), c(n)
dimension x(n**3)
index=0
do i=1,n
a2=a(i)*a(i)
do j=1,n
b2=b(j)*b(j)
a2b2=a2+b2
do k=1,n
index=index+1
x(index)=a2b2+c(k)*c(k)
enddo
enddo
enddo
+ : 4,194,304
� : 6,291,456
+ : 2,113,536
� : 2,113,664

Autre example
parameter (m=64,n=128)
dimension a(m), b(n)
t=0.
do i=1,m
x=a(i)
do j=1,n
y=b(j)
t=t+sin(sqrt(x)+sqrt(y))
enddo
enddo
parameter (m=64,n=128)
dimension a(m), b(n)
t=0.
do i=1,m
x=a(i)
sqx=sqrt(x)
do j=1,n
y=b(j)
t=t+sin(sqx+sqrt(y))
enddo
enddo
Incorrect
Correct

B) Ordre des boucles.
Considérons 2 boucles de tailles très différentes
n m
t = � � exp ( a i x j + b i y j + c i z j )
i=1 j=1
où n = 2 000 000 et m = 10

1 e approche
parameter (n=2000000,m=10)
dimension a(n), b(n), c(n)
dimension x(m), y(m), z(m)
t=0.
do i=1,n
ai=a(i)
bi=b(i)
ci=c(i)
do j=1,m
t=t+exp(ai*x(j))+exp(bi*y(j))+exp(ci*z(j))
enddo
enddo
2 e approche
parameter (n=2000000,m=10)
dimension a(n), b(n), c(n)
dimension x(m), y(m), z(m)
t=0.
do j=1,m
xj=x(j)
yj=y(j)
zj=z(j)
do i=1,n
t=t+exp(a(i)*xj)+exp(b(i)*yj)+exp(c(i)*zj)
enddo
enddo
Boucle intérieure
exécutée 2 000 000 de
fois.
Chaque fois: 30 “fetch”.
Nombre total de “fetch”:
60 000 000.
Boucle intérieure
exécutée 10 fois.
Chaque fois: 6 000 000
“fetch”.
Nombre total de “fetch”:
60 000 000.

Cache
Rapide
Lent
Cache : Capacité très faible
Processeur
Mémoire
Vitesse d’accès très élevée
Lent
Utile lorsqu’on a un petit nombre de variables utilisées très souvant.

1 e approche
parameter (n=2000000,m=10)
dimension a(n), b(n), c(n)
dimension x(m), y(m), z(m)
t=0.
do i=1,n
ai=a(i)
bi=b(i)
ci=c(i)
do j=1,m
t=t+exp(ai*x(j))+exp(bi*y(j))+exp(ci*z(j))
enddo
enddo
2 e approche
parameter (n=2000000,m=10)
dimension a(n), b(n), c(n)
dimension x(m), y(m), z(m)
t=0.
do j=1,m
xj=x(j)
yj=y(j)
zj=z(j)
do i=1,n
t=t+exp(a(i)*xj)+exp(b(i)*yj)+exp(c(i)*zj)
enddo
enddo
30 variables utilisées
2 000 000 de fois
chacunes.
La cache permet
d’accélérer le calcul.
6 000 000 de variables
utilisées 10 fois
chacunes.
La cache ne sert à rien.

1 e approche
parameter (n=2000000,m=10)
dimension a(n), b(n), c(n)
dimension x(m), y(m), z(m)
t=0.
do i=1,n
ai=a(i)
bi=b(i)
ci=c(i)
do j=1,m
t=t+exp(ai*x(j))+exp(bi*y(j))+exp(ci*z(j))
enddo
enddo
• Itération i=1 : Le processeur va chercher les 30 variables x(j), y(j),
z(j) dans la mémoire principale (lent), et ces variables sont copiées
dans la cache (lent).
• Itérations i=2, 3, ..., 2 000 000 : Le processeur va chercher les 30
variables x(j), y(j), z(j) directement dans la cache (rapide).
En général, on a intérêt à mettre la petite boucle à l’intérieur de la
grande. EXCEPTION: Machines vectorielles.

3) Ordinateurs vectoriels
Ex: Somme de 2 vecteurs: a(i) + b(i) = c(i), i = 1, … , n
a
b
c
dimension a(n), b(n), c(n)
do i=1,n
c(i)=a(i)+b(i)
enddo
ordinateur sériel :
c(1) = a(1) + b(1)
c(2) = a(2) + b(2)
c(3) = a(3) + b(3)
c(4) = a(4) + b(4)
…
ordinateur vectoriel : toutes les
additions se font simultanément

Autres examples:
copie
dimension a(n), b(n)
do i=1,n
b(i)=a(i)
enddo
dimension a(n), b(n)
do i=1,n
b(i)=a(i)+x
enddo
addition et remplacement
dimension a(n)
do i=1,n
a(i)=a(i)+x
enddo
multiplication
dimension a(n), b(n)
do i=1,n
b(i)=a(i)*x
enddo
addition multiplication et remplacement
dimension a(n)
do i=1,n
a(i)=a(i)*x
enddo
fonction intrinsèque
dimension a(n), b(n)
do i=1,n
b(i)=sin(a(i))
enddo

• Boucles multiples: seule la boucles intérieure peut
se vectoriser.
• Les boucles ne sont pas toutes vectorisables. Le
compilateur décide automatiquement quelles
boucles peuvent être vectorisées, et les vectorise
automatiquement.
• Un bon compilateur va expliquer pourquoi
certaines boucles ne vectorisent pas.

2 méthodes pour déterminer si une boucle est vectorisable:
a) les itérations de la boucles pourrait-elles physiquement s’exécuter
simultanément?
b) le résultat serait-il identique si les itérations s`exécutaient dans un
autre ordre?
dimension a(8), b(8), c(8)
do i=1,8
c(i)=a(i)+b(i)
enddo
ordre normal: m = 1, 2, 3, 4, 5, 6, 7, 8
autre ordre: m = 5, 8, 3, 6, 1, 2, 7, 4
Si les réponses sont OUI, la boucle est vectorisable.
Si les réponses sont NON, la boucle n’est pas vectorisable.

Examples de boucles non-vectorisables:
a) Input/Output
dimension a(n)
do i=1,n
read(1,*) a(i)
enddo
b) Fonctions externes ou sousroutines.
dimension a(n)
do i=1,n
x=a(i)
call SUB(x)
enddo
--------------------------------------subroutine
SUB(x)
print *, x
if(x.lt.0.) stop
return
end

Dans certains cas, on résout le problème gràce au inlining.
non-vectorisable
vectorisable
dimension a(n)
do i=1,n
x=a(i)
call WINDOW(x,xmin,xmax)
a(i)=x
enddo
--------------------------------------subroutine
WINDOW(x,xmin,xmax)
x=AMAX1(x,xmin)
x=AMIN1(x,xmax)
return
end
dimension a(n)
do i=1,n
x=a(i)
x=AMAX1(x,xmin)
x=AMIN1(x,xmax)
a(i)=x
enddo

c) Interruption prématurée
dimension a(n), b(n), c(n)
do i=1,n
c(i)=a(i)+b(i)
if(c(i).lt.0.) stop
enddo
dimension a(n), b(n), c(n)
do i=1,n
c(i)=a(i)+b(i)
if(c(i).lt.0.) go to 10
enddo
10 continue

d) Sélection
dimension a(n), b(n), c(n)
do i=1,n
if(a(i).ge.1.) then
c(i)=a(i)+b(i)**2
else
c(i)=a(i)-b(i)**2
endif
enddo
Cray et IBM ont créé des fonctions implicites spéciales pour permettre la
vectorisation: CVMGP, CVMGM, CVMGZ, CVGMN, CVMGT
Example: CVGMP(x,y,z) =
dimension a(n), b(n), c(n)
x, z � 0;
y, z < 0.
do i=1,n
c(i)=a(i)+CVMGP(b(i)**2,-b(i)**2,a(i)-1.)
enddo

e) Indices compliqués
dimension a(n), b(n), index(n)
do i=1,n
b(index(i))=b(index(i))+a(i)
enddo
Exemple concret: calcul de la densité dans le programme P 3 M.
Volume cubique contenant NP particules.
On place dans le volume une grille cubique
N � N � N.
Bût: Calculer la densité sur la grille à partir
des particules.
Chaque particules comtribuera à la densité
au point de grille le plus proche, et aux 26
points voisins (Triangular-Shaped Cloud).

subroutine assmass(r,b)
parameter (n=256,np=2097152)
dimension r(np,3), b(0:n-1,0:n-1,0:n-1)
do m=1,np
x=r(m,1)
y=r(m,2)
z=r(m,3)
ir=int(n*x)
jr=int(n*y)
kr=int(n*z)
dx=x-ir/float(n)
dy=y-jr/float(n)
dz=z-kr/float(n)
do i=-1,1
do j=-1,1
do k=-1,1
ii=ir+i
jj=jr+j
kk=kr+k
t1=0.75-0.625*i*i+dx*(0.5*i+dx*(1.5*i*i-1.))
t2=0.75-0.625*j*j+dy*(0.5*j+dy*(1.5*j*j-1.))
t3=0.75-0.625*k*k+dz*(0.5*k+dz*(1.5*k*k-1.))
b(ii,jj,kk)=b(ii,jj,kk)+t1*t2*t3
enddo
enddo
enddo
enddo
return
end

subroutine assmass(r,b)
parameter (n=256,np=2097152)
dimension r(np,3), b(0:n-1,0:n-1,0:n-1)
do i=-1,1
do j=-1,1
do k=-1,1
do m=1,np
x=r(m,1)
y=r(m,2)
z=r(m,3)
ir=int(n*x)
jr=int(n*y)
kr=int(n*z)
dx=x-ir/float(n)
dy=y-jr/float(n)
dz=z-kr/float(n)
ii=ir+i
jj=jr+j
kk=kr+k
t1=0.75-0.625*i*i+dx*(0.5*i+dx*(1.5*i*i-1.))
t2=0.75-0.625*j*j+dy*(0.5*j+dy*(1.5*j*j-1.))
t3=0.75-0.625*k*k+dz*(0.5*k+dz*(1.5*k*k-1.))
b(ii,jj,kk)=b(ii,jj,kk)+t1*t2*t3
enddo
enddo
enddo
enddo
return
end

subroutine assmass(r,b)
parameter (n=256,np=2097152)
dimension r(np,3), b(0:n-1,0:n-1,0:n-1)
dimension aux(np)
do i=-1,1
do j=-1,1
do k=-1,1
do m=1,np
x=r(m,1)
y=r(m,2)
z=r(m,3)
ir=int(n*x)
jr=int(n*y)
kr=int(n*z)
dx=x-ir/float(n)
dy=y-jr/float(n)
dz=z-kr/float(n)
t1=0.75-0.625*i*i+dx*(0.5*i+dx*(1.5*i*i-1.))
t2=0.75-0.625*j*j+dy*(0.5*j+dy*(1.5*j*j-1.))
t3=0.75-0.625*k*k+dz*(0.5*k+dz*(1.5*k*k-1.))
aux(np)=t1*t2*t3
enddo
do m=1,np
ir=int(n*x)
jr=int(n*y)
kr=int(n*z)
ii=ir+i
jj=jr+j
kk=kr+k
b(ii,jj,kk)=b(ii,jj,kk)+aux(np)
enddo
enddo
enddo
enddo
return
end

subroutine assmass(r,b)
parameter (n=256,np=2097152)
dimension r(np,3), b(0:n-1,0:n-1,0:n-1)
dimension aux(np)
common /tsc/ a(-1:1), b(-1:1), c(-1:1)
do i=-1,1
do j=-1,1
do k=-1,1
do m=1,np
x=r(m,1)
y=r(m,2)
z=r(m,3)
ir=int(n*x)
jr=int(n*y)
kr=int(n*z)
dx=x-ir/float(n)
dy=y-jr/float(n)
dz=z-kr/float(n)
t1=b(i)+dx*(c(i)+dx*a(i))
t2=b(j)+dy*(c(j)+dy*a(j))
t3=b(k)+dz*(c(k)+dz*a(k))
aux(np)=t1*t2*t3
enddo
do m=1,np
ir=int(n*x)
jr=int(n*y)
kr=int(n*z)
ii=ir+i
jj=jr+j
kk=kr+k
b(ii,jj,kk)=b(ii,jj,kk)+aux(np)
enddo
enddo
enddo
enddo
return
end
a(i) = 1.5*i*i-1
b(i) = 0.75-0.625*i*i
c(i) = 0.5*i

subroutine assmass(r,b)
parameter (n=256,np=2097152)
dimension r(np,3), b(0:n-1,0:n-1,0:n-1)
dimension ir(np), jr(np), kr(np), dx(np), dy(np), dz(np)
dimension aux(np)
common /tsc/ a(-1:1), b(-1:1), c(-1:1)
do m=1,np
x=r(m,1)
y=r(m,2)
z=r(m,3)
ir(m)=int(n*x)
jr(m)=int(n*y)
kr(m)=int(n*z)
dx(m)=x-ir/float(n)
dy(m)=y-jr/float(n)
dz(m)=z-kr/float(n)
enddo
do i=-1,1
do j=-1,1
do k=-1,1
do m=1,np
t1=b(i)+dx(m)*(c(i)+dx(m)*a(i))
t2=b(j)+dy(m)*(c(j)+dy(m)*a(j))
t3=b(k)+dz(m)*(c(k)+dz(m)*a(k))
aux(np)=t1*t2*t3
enddo
do m=1,np
ii=ir(m)+i
jj=jr(m)+j
kk=kr(m)+k
b(ii,jj,kk)=b(ii,jj,kk)+aux(np)
enddo
enddo
enddo
enddo
return
end

subroutine assmass(r,b)
parameter (n=256,np=2097152)
dimension r(np,3), b(0:n-1,0:n-1,0:n-1)
dimension ir(np), jr(np), kr(np), dx(np), dy(np), dz(np)
dimension aux(np)
common /tsc/ a(-1:1), b(-1:1), c(-1:1)
on=1./float(n)
do m=1,np
x=r(m,1)
y=r(m,2)
z=r(m,3)
ir(m)=int(n*x)
jr(m)=int(n*y)
kr(m)=int(n*z)
dx(m)=x-ir*on
dy(m)=y-jr*on
dz(m)=z-kr*on
enddo
do i=-1,1
do j=-1,1
do k=-1,1
do m=1,np
t1=b(i)+dx(m)*(c(i)+dx(m)*a(i))
t2=b(j)+dy(m)*(c(j)+dy(m)*a(j))
t3=b(k)+dz(m)*(c(k)+dz(m)*a(k))
aux(np)=t1*t2*t3
enddo
do m=1,np
ii=ir(m)+i
jj=jr(m)+j
kk=kr(m)+k
b(ii,jj,kk)=b(ii,jj,kk)+aux(np)
enddo
enddo
enddo
enddo
return
end

4) Ordinateurs parallèles
Ordinateur vectoriel: Un seul processeur, qui peux faire des opérations
simultanément sur toutes les composantes de vecteurs.
Ordinateur parallèle: Plusieurs processeurs sériels qui se partage le calcul.

CPU1
Exécution d’un programme parallèle
région sériele région parallèle région sériele région parallèle région sériele
processeur maître
CPU1 CPU1 CPU1 CPU1
CPU2
CPU3
CPU4
CPU5
CPU6
CPU7
CPU8
CPU2
CPU3
CPU4
CPU5
CPU6
CPU7
CPU8

CPU1
Cache 1
Mémoire Partagée
CPU2
Cache 2
Mémoire
CPU3
Cache 3
CPU4
Cache 4

CPU1
Cache 1
Mem1
CPU2
Cache 2
Mémoire Distribuée
CPU3
Cache 3
CPU4
Cache 4
Mem2 Mem3 Mem4

Ordinateur vectoriel: Le compilateur vectorise les boucles
automatiquement.
Ordinateur parallèle: Le programme doit contenir des
instructions pour parallèliser les boucles.
Systèmes avec mémoire partagée: OpenMP
Systèmes avec mémoire distribuée: MPI

Exemple: parallèlisation d’une boucle avec OpenMP, sur 8 processeurs.
dimension a(1024), b(1024), c(1024)
!$omp parallel do shared(a,b,c) private(i,x,y,z)
do i=1,1024
x=a(i)
y=b(i)
z=x**2+y**2
if(z.gt.10.) then
c(i)=x
else
c(i)=y
endif
enddo
!$omp end parallel do

processeur 1 processeur 2 processeur 3
do i=1,128
x=a(i)
y=b(i)
z=x**2+y**2
if(z.gt.10.) then
c(i)=x
else
c(i)=y
endif
enddo
do i=385,512
x=a(i)
y=b(i)
z=x**2+y**2
if(z.gt.10.) then
c(i)=x
else
c(i)=y
endif
enddo
do i=769,896
x=a(i)
y=b(i)
z=x**2+y**2
if(z.gt.10.) then
c(i)=x
else
c(i)=y
endif
enddo
do i=129,256
x=a(i)
y=b(i)
z=x**2+y**2
if(z.gt.10.) then
c(i)=x
else
c(i)=y
endif
enddo
do i=513,640
x=a(i)
y=b(i)
z=x**2+y**2
if(z.gt.10.) then
c(i)=x
else
c(i)=y
endif
enddo
do i=897,1024
x=a(i)
y=b(i)
z=x**2+y**2
if(z.gt.10.) then
c(i)=x
else
c(i)=y
endif
enddo
do i=257,384
x=a(i)
y=b(i)
z=x**2+y**2
if(z.gt.10.) then
c(i)=x
else
c(i)=y
endif
enddo
processeur 4 processeur 5 processeur 6
processeur 7 processeur 8
do i=641,768
x=a(i)
y=b(i)
z=x**2+y**2
if(z.gt.10.) then
c(i)=x
else
c(i)=y
endif
enddo

Parallèlisation des boucles:
• Dans le cas de boucles multiples, c’est la boucle
extérieure qui se parallèlise.
• Non-parallèlisation: on retrouve en gros les mêmes
critères que la non-vectorisation.
a) Input/Output
b) Interruption prématurée
c) Indices compliqués
Exceptions: o Sélection
o Fonctions externes et sousroutines (dangereux)

Autres concepts:
• Décomposition du domaine.
• Balance de charge.
• Relation d’échelle (scalability).

5) Résumé et Conclusion
• Le calcul de haute performance est devenu un outil indispensable de
l’astrophysique théorique.
• De grands progrès ont été réalisés durant les 30 dernières années.
o Sofware (meilleurs algorithmes)
o Hardware (processeurs plus rapides, nouvelles architectures)
• Les ordinateurs sériels ne sont pratiquement plus utilisés pour le CHP
(les problèmes sont devenus trop gros).
• Les ordinateurs vectoriels ne sont plus très utilisés.
• Présent: ordinateurs parallèles avec mémoire partagée ou distribuée
• Avenir (?): o Les mémoires partagées seront moins utilisées (les problèmes
seront trop gros).
o Ordinateur parallèle avec processeurs vectoriels (existe déjà).
o Ordinateur parallèle avec custom hardware (GRAPE).