Upgrade to Pro — share decks privately, control downloads, hide ads and more …

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

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

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

Other Decks in Science

Transcript

  1. Universit´
    e Libre de Bruxelles

    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 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

    View Slide

  2. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    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

  3. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    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

    View Slide

  4. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    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

    View Slide

  5. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    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

    View Slide

  6. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    eponses
    Interpr´
    etation abstraite
    Abstraction de machine abstraite (Abstracting Abstract Machine, AAM) :

    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.

    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

    View Slide

  7. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    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

    View Slide

  8. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    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

    View Slide

  9. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    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

  10. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    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

    View Slide

  11. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    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

    View Slide

  12. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    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

    View Slide

  13. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    eponses

    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

    View Slide

  14. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    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)

    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

  15. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    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

    View Slide

  16. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    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.

    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´

    es lors de l’initialisation et utilis´
    es jusqu’`
    a la fin.
    p = 3 dans les sch´
    emas qui suivent.
    14 / 30

    View Slide

  17. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    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

    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

    View Slide

  18. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    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

    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

    View Slide

  19. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    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

    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

    View Slide

  20. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    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

    View Slide

  21. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    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

  22. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    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

  23. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    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

  24. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    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

    View Slide

  25. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    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

  26. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    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

  27. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    eponses

    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

  28. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    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

    View Slide

  29. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    eponses

    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

    View Slide

  30. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    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

    View Slide

  31. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    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

    View Slide

  32. Probl´
    ematique
    Interpr´
    etation
    abstraite
    Parall´
    elisme :
    mod`
    ele d’acteurs
    Algorithmes
    parall`
    eles

    esultats
    Conclusion
    Questions/

    eponses
    Questions/r´
    eponses. . .

    ef´
    erences :
    Cette pr´
    esentation sur :
    https://speakerdeck.com/opimedia/
    parallelisation-dun-interpreteur-abstrait-au-travers-du-modele-acteur

    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/

    esultats :
    http://www.opimedia.be/CV/2017-2018-ULB/MEMO-F524-Masters-thesis/benchmark-results/
    30 / 30

    View Slide