Parallélisation d'un interpréteur abstrait, au travers du modèle acteur

Universit´
e Libre de Bruxelles
D´
epartement d’Informatique
MEMO-F524 M´
emoire
Parall´
elisation d’un interpr´
eteur abstrait
au travers du mod`
ele acteur
— Application `
a l’interpr´
eteur abstrait Scala-AM —
Pr´
esentation finale
Olivier Pirson — [email protected]
5 septembre 2019
(Derni`
ere modiﬁcation : 18 juin 2020)
https://speakerdeck.com/opimedia/
parallelisation-dun-interpreteur-abstrait-au-travers-du-modele-acteur
Vrije Universiteit Brussel
Promoteurs Coen De Roover
Wolfgang De Meuter
Conseiller Quentin Sti´
evenart

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
1 La probl´
ematique : parall´
eliser l’interpr´
etation abstraite
2 Essentiel de l’interpr´
etation abstraite pour cette pr´
esentation
3 Essentiel du parall´
elisme et du mod`
ele d’acteurs pour cette pr´
esentation
4 Algorithmes parall`
eles
5 R´
esultats
6 Conclusion
7 Questions/r´
eponses
2 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
D’un probl`
eme non calculable
`
a une technique suﬃsamment rapide
Nous voulons des programmes corrects.
↓
Analyse statique :
automatiser la preuve de propri´
et´
es sur les programmes
(ou la mise en ´
evidence de bogues)
sans ex´
ecution des programmes.
Pour chaque propri´
et´
e non triviale, c’est un probl`
eme non calculable.
(th´
eor`
eme de Rice)
↓
Interpr´
etation abstraite :
technique d’analyse statique qui
´
evalue une abstraction (sur-approximation) des programmes.
Calculable mais peut ˆ
etre trop lent
(en particulier pour langages dynamiques avec fonctions d’ordre sup´
erieur).
↓
Possibilit´
e pour la rendre plus rapide : parall´
eliser. . .
3 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
Parall´
elisation de Scala-AM
Scala-AM : framework ´
ecrit en Scala par Quentin Sti´
evenart.
Permet d’exp´
erimenter avec les diﬀ´
erents aspects d’un interpr´
eteur abstrait.
↓
Restriction `
a la machine abstraite la plus simple (AAM), sans optimisation.
Restriction de l’analyse aux programmes Scheme.
↓
Ajout de 3×3 impl´
ementations parall`
eles (ParAAM∗)
utilisant les acteurs de la biblioth`
eque Akka.
↓
Scala-Par-AM
https://bitbucket.org/OPiMedia/scala-par-am
4 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
1 La probl´
ematique : parall´
etation abstraite
esentation
elisme et du mod`
esentation
eles
5 R´
esultats
6 Conclusion
7 Questions/r´
eponses
5 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
Interpr´
etation abstraite
Abstraction de machine abstraite (Abstracting Abstract Machine, AAM) :
d´
erive syst´
ematiquement la s´
emantique d’un langage de programmation
pour en d´
eduire une s´
emantique abstraite
qui mime (sur-approxime) la s´
emantique concr`
ete.
G´
en´
eralisation :
toutes les entr´
ees sont consid´
er´
ees.
Simpliﬁcations :
Les valeurs concr`
etes sont sur-approxim´
ees (par exemple par leur type).
La s´
emantique concr`
ete du langage est adapt´
ee.
Bas´
e sur la notion de treillis :
ordre partiel avec des propri´
et´
es suppl´
ementaires
garantissant l’existence d’un point ﬁxe,
et pr´
eservant au mieux les informations approch´
ees.
6 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
Graphe d’´
etats
Interpr´
eteur concret selon la s´
emantique par petits pas.
Trace :
ex´
ecution concr`
ete sur une seule entr´
ee par un interpr´
eteur concret.
e (le programme `
a ex´
ecuter)
s0
s1
s2
s3
s4 · · · sk
sans ﬁn
ou
fonction
d’injection
fonction de transition concr`
ete
7 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
Graphe d’´
etats
Interpr´
eteur concret selon la s´
emantique par petits pas.
Trace :
ex´
ecution concr`
ete sur une seule entr´
ee par un interpr´
eteur concret.
e (le programme `
a ex´
ecuter/analyser)
s0
s1
s2
s3
s4 · · · sk
sans ﬁn
ou
s0
s1
s2
s3
s4
s3′
fonction
d’injection
fonction
d’injection
fonction de transition abstraite
fonction
d’abstraction α
Graphe d’´
etats :
interpr´
etation abstraite sur toutes les entr´
ees.
“L’abstraction simule le concret” [Might, 2011] sur toutes les entr´
ees.
7 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
Graphe d’´
etats
e (le programme `
a analyser)
s0
s1
s2
s3
s4
s3′
fonction
d’injection
fonction de transition abstraite
Graphe d’´
etats :
interpr´
etation abstraite sur toutes les entr´
ees.
“L’abstraction simule le concret” [Might, 2011] sur toutes les entr´
ees.
7 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
Algorithme s´
equentiel de calcul du point ﬁxe
(letrec ((abs (lambda (x) (if (>= x 0) x (- x))))) (abs -42))
état initial
(abs -42)
fonction de transition
(if (>= x 0) x (- x))
(>= x 0)
ko(Bool)
x (- x)
ko(Int)
état final
( define (abs x)
(if (>= x 0)
x
(- x)))
(abs -42)
s s
s
. . .
worklist
s s
s
. . .
currentWorklist
state s s . . .
successors
tout prendre
foreach
step
(si pas d´
ej`
a visit´
e)
0 worklist = ensemble vide
1 visited = ensemble vide
2 halted = ensemble vide
3 graph = graphe vide
4
5 worklist = worklist ∪ {´
etat initial}
6 repeat
7 state = prendre un ´
etat de worklist
8 if state /
∈ visited then
9 visited = visited ∪ {state }
10 if state est un ´
etat ﬁnal then
11 halted = halted ∪ {state }
12 else
13 successors = step (state )
14 worklist = worklist ∪ successors
15 graph = graph ∪ {arˆ
ete state → s | s ∈ successors }
16 until worklist est vide
Le graphe d’´
etats complet
ne d´
epend pas de l’ordre d’´
evaluation.
Crucial pour la parall´
elisation,
qui va ´
evaluer en parall`
ele le contenu de la worklist.
´
Equivalent au pseudo-code, boucler sur
8 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
Autre simple exemple Scheme, avec un graphe d’´
etats plus ´
etoﬀ´
e
(letrec ((fibonacci (lambda (n) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2))))))) (fibonacci 10))
0
(fibonacci 10)
1
(if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2))))
2
(<= n 1)
3
ko(Bool)
4
n
5
(+ (fibonacci (- n 1)) (fibonacci (- n 2)))
6
ko(Int)
7
(fibonacci (- n 1))
8
(- n 1)
9
ko(Int)
10
11
(<= n 1)
12
ko(Bool)
13
n
14
15
n
16
17
ko(Int)
18
(fibonacci (- n 1))
19
ko(Int)
20
(fibonacci (- n 1))
21
(- n 1)
24
(fibonacci (- n 2))
23
(- n 1)
22
ko(Int)
27
(- n 2)
26
ko(Int)
25
30
ko(Int)
29
28
(<= n 1)
32
31
(<= n 1)
34
ko(Bool)
33
n
36
37
n
38
39
ko(Bool)
35
n
42
43
n
44
45
46
n
47
ko(Int)
40
ko(Int)
41
(fibonacci (- n 2))
54
(fibonacci (- n 2))
55
ko(Int)
48
(fibonacci (- n 1))
49
ko(Int)
50
(fibonacci (- n 1))
51
(fibonacci (- n 1))
52
ko(Int)
53
(fibonacci (- n 2))
61
(- n 1)
60
(- n 1)
59
(- n 1)
58
(- n 2)
56
(- n 2)
57
ko(Int)
67
ko(Int)
66
ko(Int)
65
ko(Int)
64
ko(Int)
63
(- n 2)
62
ko(Int)
73
72
71
70
69
68
(<= n 1)
75
(<= n 1)
77
(<= n 1)
76
74
ko(Bool)
78
ko(Bool)
80
ko(Bool)
79
n
93
94
95
96
n
97
n
98
87
n
88
89
n
90
91
n
92
81
n
82
83
84
n
85
n
86
ko(Int)
108
(fibonacci (- n 1))
100
ko(Int)
109
ko(Int)
110
(fibonacci (- n 1))
103
ko(Int)
104
ko(Int)
105
(fibonacci (- n 1))
106
ko(Int)
107
ko(Int)
99
ko(Int)
101
ko(Int)
102
(- n 1)
111
(fibonacci (- n 2))
115
(fibonacci (- n 2))
118
(- n 1)
117
(fibonacci (- n 2))
116
(- n 1)
114
(fibonacci (- n 2))
112
(fibonacci (- n 2))
113
ko(Int)
126
(- n 2)
124
(- n 2)
125
ko(Int)
123
(- n 2)
120
(- n 2)
122
ko(Int)
121
(- n 2)
119
ko(Int)
134
ko(Int)
133
132
ko(Int)
131
130
ko(Int)
129
ko(Int)
128
127
(<= n 1)
141
140
139
(<= n 1)
138
137
136
135
(<= n 1)
145
ko(Bool)
144
(<= n 1)
143
ko(Bool)
142
154
155
n
156
n
157
158
n
159
ko(Bool)
153
n
147
148
n
149
150
n
151
152
ko(Bool)
146
172
n
173
174
n
175
176
n
177
ko(Int)
169
ko(Int)
170
ko(Int)
171
163
164
165
n
166
n
167
n
168
ko(Int)
160
ko(Int)
161
ko(Int)
162
(fibonacci (- n 2))
183
(fibonacci (- n 2))
191
(fibonacci (- n 2))
192
(fibonacci (- n 1))
186
(fibonacci (- n 1))
187
ko(Int)
188
ko(Int)
189
ko(Int)
190
(fibonacci (- n 2))
184
(fibonacci (- n 2))
185
(fibonacci (- n 1))
178
ko(Int)
179
(fibonacci (- n 1))
180
ko(Int)
181
ko(Int)
182
(- n 1)
201
(- n 1)
200
(- n 2)
195
(- n 2)
198
(- n 2)
199
(- n 1)
197
(- n 1)
196
(- n 2)
193
(- n 2)
194
ko(Int)
210
ko(Int)
209
ko(Int)
208
ko(Int)
207
ko(Int)
206
ko(Int)
205
ko(Int)
204
ko(Int)
203
ko(Int)
202
219
218
217
216
215
214
213
212
211
(<= n 1)
222
(<= n 1)
220
(<= n 1)
221
ko(Bool)
224
ko(Bool)
225
ko(Bool)
223
238
n
239
n
240
n
241
242
243
232
n
233
n
234
235
n
236
237
226
227
n
228
n
229
n
230
231
(fibonacci (- n 1))
250
ko(Int)
251
ko(Int)
252
ko(Int)
253
ko(Int)
247
ko(Int)
248
ko(Int)
249
ko(Int)
244
ko(Int)
245
ko(Int)
246
(fibonacci (- n 2))
255
(- n 1)
254
ko(Int)
257
(- n 2)
256
ko(Int)
259
258
260
(<= n 1)
261
ko(Bool)
262
n
263
n
264
265
266
n
267
268
ko(Int)
269
ko(Int)
270
(fibonacci (- n 1))
271
ko(Int)
272
(- n 1)
273
ko(Int)
274
275
( define ( fibonacci n)
(if (<= n 1)
n
(+ ( fibonacci (- n 1))
( fibonacci (- n 2)))))
( fibonacci 10)
# ´
etat : 276
# arc : 346
# valeur ﬁnale : 1 (Int)
# d´
ej`
a visit´
e : 71
# de successeurs par taille :
# de taille 1 : 231
# de taille 2 : 13
# de taille 3 : 3
# de taille 4 : 2
# de taille 6 : 12
Taille maximale
de la worklist : 24
(pour le parcours s´
equentiel)
9 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
1 La probl´
ematique : parall´
etation abstraite
esentation
elisme et du mod`
esentation
eles
5 R´
esultats
6 Conclusion
7 Questions/r´
eponses
10 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
M´
etriques pour ´
evaluer les performances
p : le nombre de processeurs/cœurs
Ts´
eq
: temps d’ex´
ecution de l’impl´
ementation s´
equentielle de r´
ef´
erence
Tpar
: temps d’ex´
ecution de l’impl´
ementation parall`
ele consid´
er´
ee
acc´
el´
eration = Ts´
eq
Tpar
= nombre de fois plus rapide
(id´
ealement ´
egale `
a p, mais g´
en´
eralement inf´
erieure)
eﬃcacit´
e = acc´
el´
eration
p
= Ts´
eq
p Tpar
= taux d’occupation des p proc./cœurs
(id´
ealement ´
egale `
a 1, mais g´
en´
eralement inf´
erieure)
11 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
Mod`
ele d’acteurs
Mod`
ele de parall´
elisme de haut niveau constitu´
ees d’acteurs.
(Mod`
ele par d´
efaut en Scala, utilisant la biblioth`
eque Akka.)
Acteur :
Entit´
e isol´
ee, avec des donn´
ees internes priv´
ees.
Communique avec les autres acteurs par envoi de message asynchrone.
Dispose d’une boˆ
ıte aux lettres
dans laquelle s’accumule les messages rec
¸us (dans l’ordre d’arriv´
ee).
Chaque message r´
eceptionn´
e (un `
a la fois, dans l’ordre d’arriv´
ee)
d´
eclenche le code associ´
e qui s’ex´
ecute s´
equentiellement.
. . .
actor
actor actor
mailbox
mailbox
mailbox
Tous les acteurs s’ex´
ecutent en parall`
ele
(si les ressources mat´
erielles le permettent).
12 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
1 La probl´
ematique : parall´
etation abstraite
esentation
elisme et du mod`
esentation
eles
5 R´
esultats
6 Conclusion
7 Questions/r´
eponses
13 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
´
Evocation des 3 × 3 algorithmes parall`
eles impl´
ement´
es
Par message envoie Loop – SenderAggregator Concurrent – Sender Concurrent
un seul ´
etat L-SA-state C-S-state C-state
ensemble d’´
etats L-SA-set C-S-set C-set
part “´
egale” d’´
etats L-SA-part C-S-part C-part
3 familles d’algorithmes, s’am´
eliorant de gauche `
a droite.
D´
eclin´
ee en 3 versions, s’am´
eliorant du haut vers le bas.
Les versions ∗-set utilisent la d´
ecoupe “naturelle” en ensembles
induite par la structure hybride de worklist choisie :
une liste d’ensembles d’´
etats.
s s s s s
s
Chacun de ses ensembles correspond, suivant les versions,
`
a un ensemble de successeurs ou `
a l’accumulation locale des successeurs.
Pour chaque algorithme,
p acteurs sont cr´
e´
es lors de l’initialisation et utilis´
es jusqu’`
a la ﬁn.
p = 3 dans les sch´
emas qui suivent.
14 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
Algorithme parall`
ele L-SA-part
Dans une boucle, un acteur sp´
ecifique unique senderAggregator
envoie les ´
etats aux n = p − 1 acteurs eval
et r´
eceptionne les ´
etats `
a ajouter `
a la worklist.
senderAggregator
chaque partie de
currentWorklist
barri`
ere
boucle
eval0
eval1
s s
s
. . .
worklist
s s
s
. . .
currentWorklist
d´
ecoup´
ee
en parts
visited
s s . . .
states
s s . . .
states
state
state
s s . . .
succ.
s s . . .
succ.
s s
s
. . .
newStates
newStatesSize
s s
s
. . .
newStates
newStatesSize
localHalted, localEdges
tout prendre
Eval
foreach
step
(si pas. . .)
∪
Eval
foreach
step
(si pas. . .)
∪
Result
Result
Un acteur sp´
ecifique n’effectue aucune ´
evaluation.
Barri`
ere, `
a chaque tour de boucle.
15 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
Algorithme parall`
ele C-S-part
Un acteur sp´
ecifique unique sender
envoie les ´
etats aux n = p − 1 acteurs eval
qui eux-mˆ
emes effectuent les mises `
a jour de fac
¸on concurrente.
sender
une partie de
currentWorklist
pour chaque acteur eval disponible
eval0
eval1
s s
s
. . .
worklist
currentWorklistSize
s s
s
. . .
currentWorklist
d´
ecoup´
ee
en parts
visited
s s . . .
states
s s . . .
states
state
state
s s . . .
succ.
s s . . .
succ.
s s
s
. . .
newStates
newStatesSize
s s
s
. . .
newStates
newStatesSize
acc`
es atomique
tout prendre
availableActorEvals
availableActorEvalsSize
Eval
foreach
step
(si pas. . .)
∪
Eval
foreach
step
(si pas. . .)
∪
mise `
a jour
mise `
a jour
ActorEvalAvailable
ActorEvalAvailable
Un acteur sp´
ecifique n’effectue aucune ´
evaluation
16 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
Algorithme parall`
ele C-part
Chacun des n = p acteurs eval envoie les ´
etats aux autres
et eﬀectue les mises `
a jour de fac
¸on concurrente.
eval0
une part de
newStates
pour chaque acteur eval disponible
eval1
eval2
visited
availableActorEvals
availableActorEvalsSize
´
evaluation
newStates
d´
ecoup´
ee
en parts
s s . . .
states
s s . . .
states
state
state
s s . . .
succ.
s s . . .
succ.
s s
s
. . .
newStates
newStatesSize
s s
s
. . .
newStates
newStatesSize
distribution
distribution
acc`
es atomique
Eval
foreach
step
(si pas. . .)
∪
Eval
foreach
step
(si pas. . .)
∪
mise `
a jour
Dans cette version C-part il n’y a plus de worklist globale.
17 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
1 La probl´
ematique : parall´
etation abstraite
esentation
elisme et du mod`
esentation
eles
5 R´
esultats
6 Conclusion
7 Questions/r´
eponses
18 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
Ordinateur utilis´
e : Bertha
Sauf mention contraire,
les r´
esultats qui suivent ont ´
et´
e calcul´
es sur l’ordinateur Bertha :
2 processeurs de 4 cœurs physiques ×2 avec l’Hyper-Threading.
Donc 8 cœurs physiques et 16 cœurs logiques.
Moyennes sur 10 ou 30 r´
ep´
etitions.
19 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
Acc´
el´
eration pour le programme Scheme linear 10000
state
set
part
L-SA C-S C s´
equentiel identit´
e
0
0.2
0.4
0.6
0.8
1
0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32
accélération
p
Le graphe d’´
etats pour linear 10000 est compl`
etement lin´
eaire,
donc aucune (selon nos algorithmes) parall´
elisation n’est possible.
20 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
Acc´
el´
eration pour linear 5000 gen4fibonacci recur
0
0.5
1
1.5
2
2.5
3
3.5
4
0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32
accélération
p
Le graphe d’´
etats avec une chaˆ
ıne initiale non n´
egligeable,
d’une proportion β = L
N
= 15006
64855
≃ 0, 231.
La courbe en marron exprime la borne sup´
erieure indicative
pour cette longueur de chaˆ
ıne initiale : acc´
el´
eration = p
(p−1)β+1
.
p = 8 = nombre de cœurs physiques
21 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
Acc´
el´
eration pour primtest
state
set
part
L-SA C-S C s´
equentiel identit´
e
0
1
2
3
4
5
6
0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32
accélération
p
0
1
2
3
4
5
0 4 8 12 16 20 24 28 32 36 40 44 48 52 56 60 64
accélération
p
`
A gauche sur l’ordinateur Bertha avec 8 cœurs physiques.
Les r´
esultats de droite ont ´
et´
e calcul´
es sur l’ordinateur Serenity :
4 processeurs de 16 cœurs physiques.
Donc 64 cœurs physiques.
Les meilleurs algorithmes proﬁtent des cœurs physiques
mais jusqu’`
a une certaine limite.
22 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
Acc´
el´
eration pour kcfa worst case 40 et qsort
state
set
part
L-SA C-S C s´
equentiel identit´
e
0
1
2
3
4
5
0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32
accélération
p
0
1
2
3
4
5
0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32
accélération
p
`
A gauche pour kcfa worst case 40, `
a droite pour qsort.
Les performances de l’algorithme C-S-set
varient ´
enorm´
ement d’un programme Scheme `
a l’autre.
23 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
Acc´
el´
eration et efficacit´
e pour qsort sur Hydra
state
set
part
L-SA C-S C s´
equentiel identit´
e
0
1
2
3
4
5
6
7
8
9
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
accélération
p
0
0.2
0.4
0.6
0.8
1
1.2
1.4
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
efficacité
p
Les r´
esultats qui suivent ont ´
et´
e calcul´
es sur un ordinateur du cluster
Hydra : 2 processeurs de 20 cœurs physiques.
Donc 40 cœurs physiques. (Mais uniquement 20 d´
emand´
es.)
Confirme que le meilleur algorithme est C-part.
La diff´
erence avec C-S-part
est due `
a l’acteur en moins qui effectue les ´
evaluations.
Ce sont les meilleurs r´
esultats obtenus.
Acc´
el´
eration croissante jusque p = 20.
24 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
R´
esum´
e des performances
Par message envoie Loop – SenderAggregator Concurrent – Sender Concurrent
un seul ´
etat L-SA-state C-S-state C-state
ensemble d’´
etats L-SA-set C-S-set C-set
part “´
egale” d’´
etats L-SA-part C-S-part C-part
# acteur eval n = p − 1 n = p − 1 n = p
Contrˆ
ole barri`
ere entre it´
erations synchronisation synchronisation
Envoi ´
etat(s) par l’acteur sp´
ecifique l’acteur sp´
ecifique chaque eval
envoie tout associe disponibilit´
e associe disponibilit´
e
´
etats/acteurs ´
etats/acteurs
Mise `
a jour par l’acteur sp´
ecifique chaque eval chaque eval
Performances mauvaises variables bonnes
De mani`
ere g´
en´
eral les impl´
ementations C-∗ sont les meilleures.
Les r´
esultats confirment que l’impl´
ementation C-part,
suppos´
ee la meilleure selon les deux axes d’am´
eliorations,
est bien la meilleure.
Les performances C-part sont bonnes lorsqu’une parall´
elisation est possible
de part la structure du graphe d’´
etats.
Et son surcout est minimis´
e dans les portions lin´
eaires du graphe d’´
etats.
Les r´
esultats confirment aussi que les performances sont limit´
ees
par la structure du graphe d’´
etats.
25 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
1 La probl´
ematique : parall´
etation abstraite
esentation
elisme et du mod`
esentation
eles
5 R´
esultats
6 Conclusion
7 Questions/r´
eponses
26 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
R´
esum´
e
L’objectif ´
etait d’acc´
el´
erer l’interpr´
etation abstraite en la parall´
elisant.
Le framework Scala-AM a servi de base
avec les acteurs de la biblioth`
eque Akka.
3 familles successives d’algorithmes ont ´
et´
e impl´
ement´
ees et ´
evalu´
ees :
la 1re L-SA-∗ directement issue de l’algorithme s´
equentiel,
la 2e C-S-∗ supprimant la barri`
ere,
et la 3e C-∗ n’ayant plus d’acteur sp´
eciﬁque.
Les r´
esultats conﬁrment les performances de la 3e C-∗
et en particulier du meilleur algorithme suppos´
e C-part.
27 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
Perspectives
Utiliser les mesures statistiques impl´
ement´
ees dans Scala-Par-AM
et les mettre en relation avec les performances.
Aﬁn de mieux comprendre la dynamique d’´
evaluation des algorithmes
et tenter d’´
evaluer leur degr´
e de parall´
elisation possible.
´
Evaluer les performances avec d’autres abstractions,
en pratiquant des analyses en particuliers.
´
Evaluer les performances dans un cadre distribu´
e
(en excluant les versions state).
´
Evaluer les meilleures impl´
ementations
sur de plus gros programmes Scheme, plus r´
ealistes.
Tester la structure hybride de la worklist
sur de plus gros programmes Scheme.
28 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
1 La probl´
ematique : parall´
etation abstraite
esentation
elisme et du mod`
esentation
eles
5 R´
esultats
6 Conclusion
7 Questions/r´
eponses
29 / 30

View Slide

Probl´
ematique
Interpr´
etation
abstraite
Parall´
elisme :
mod`
ele d’acteurs
Algorithmes
parall`
eles
R´
esultats
Conclusion
Questions/
r´
eponses
Questions/r´
eponses. . .
R´
ef´
erences :
Cette pr´
esentation sur :
https://speakerdeck.com/opimedia/
parallelisation-dun-interpreteur-abstrait-au-travers-du-modele-acteur
M´
emoire Parall´
elisation d’un interpr´
eteur abstrait, au travers du
mod`
ele acteur — Application `
a l’interpr´
eteur abstrait Scala-AM :
https://bitbucket.org/OPiMedia/efficient-parallel-abstract-interpreter-in-scala/
Impl´
ementation :
Scala-Par-AM – https://bitbucket.org/OPiMedia/scala-par-am/
R´
esultats :
http://www.opimedia.be/CV/2017-2018-ULB/MEMO-F524-Masters-thesis/benchmark-results/
30 / 30

View Slide

Parallélisation d'un interpréteur abstrait, au travers du modèle acteur

Parallélisation d'un interpréteur abstrait, au travers du modèle acteur

🌳 Olivier Pirson — OPi 🇧🇪🇫🇷🇬🇧 🐧 👨‍💻 👨‍🔬

More Decks by 🌳 Olivier Pirson — OPi 🇧🇪🇫🇷🇬🇧 🐧 👨‍💻 👨‍🔬

Other Decks in Science

Featured

Transcript