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
— Application à l'interpréteur abstrait Scala-AM
— Présentation finale

Presentation for this master thesis:
https://bitbucket.org/OPiMedia/efficient-parallel-abstract-interpreter-in-scala

Transcript

1. 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 — opi@opimedia.be 5 septembre 2019 (Derni` ere modification : 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
2. 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
3. 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 suffisamment 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
4. 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 diff´ 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
5. 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 5 / 30
6. 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. Simplifications : 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 fixe, et pr´ eservant au mieux les informations approch´ ees. 6 / 30
7. 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 fin ou fonction d’injection fonction de transition concr` ete 7 / 30
8. 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 fin 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
9. 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
10. 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 fixe (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 final 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
11. 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 ´ etoff´ 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 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 11 (<= n 1) 12 ko(Bool) 13 n 14 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 15 n 16 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 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 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 30 ko(Int) 29 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 28 (<= n 1) 32 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 31 (<= n 1) 34 ko(Bool) 33 n 36 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 37 n 38 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 39 ko(Bool) 35 n 42 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 43 n 44 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 45 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 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 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 72 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 71 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 70 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 69 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 68 (<= n 1) 75 (<= n 1) 77 (<= n 1) 76 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 74 ko(Bool) 78 ko(Bool) 80 ko(Bool) 79 n 93 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 94 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 95 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 96 n 97 n 98 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 87 n 88 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 89 n 90 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 91 n 92 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 81 n 82 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 83 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 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 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 132 ko(Int) 131 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 130 ko(Int) 129 ko(Int) 128 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 127 (<= n 1) 141 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 140 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 139 (<= n 1) 138 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 137 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 136 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 135 (<= n 1) 145 ko(Bool) 144 (<= n 1) 143 ko(Bool) 142 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 154 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 155 n 156 n 157 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 158 n 159 ko(Bool) 153 n 147 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 148 n 149 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 150 n 151 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 152 ko(Bool) 146 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 172 n 173 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 174 n 175 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 176 n 177 ko(Int) 169 ko(Int) 170 ko(Int) 171 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 163 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 164 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 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 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 219 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 218 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 217 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 216 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 215 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 214 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 213 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 212 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 211 (<= n 1) 222 (<= n 1) 220 (<= n 1) 221 ko(Bool) 224 ko(Bool) 225 ko(Bool) 223 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 238 n 239 n 240 n 241 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 242 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 243 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 232 n 233 n 234 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 235 n 236 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 237 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 226 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 227 n 228 n 229 n 230 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 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 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 258 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 260 (<= n 1) 261 ko(Bool) 262 n 263 n 264 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 265 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 266 n 267 (+ (fibonacci (- n 1)) (fibonacci (- n 2))) 268 ko(Int) 269 ko(Int) 270 (fibonacci (- n 1)) 271 ko(Int) 272 (- n 1) 273 ko(Int) 274 (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) 275 ( define ( fibonacci n) (if (<= n 1) n (+ ( fibonacci (- n 1)) ( fibonacci (- n 2))))) ( fibonacci 10) # ´ etat : 276 # arc : 346 # valeur finale : 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
12. 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 10 / 30
13. 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) efficacit´ 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
14. 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
15. 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 13 / 30
16. 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 fin. p = 3 dans les sch´ emas qui suivent. 14 / 30
17. 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 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
18. 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 localHalted, localEdges localHalted, localEdges 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
19. 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 effectue 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 localHalted, localEdges localHalted, localEdges 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
20. 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 18 / 30
21. 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
22. 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
23. 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
24. 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 profitent des cœurs physiques mais jusqu’` a une certaine limite. 22 / 30
25. 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
26. 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
27. 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
28. 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 26 / 30
29. 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´ ecifique. Les r´ esultats confirment les performances de la 3e C-∗ et en particulier du meilleur algorithme suppos´ e C-part. 27 / 30
30. 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. Afin 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
31. 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 29 / 30
32. 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