Efficient Parallel Abstract Interpreter in Scala — 3x3 Parallel Implementations

Transcript

1. Universit´ e Libre de Bruxelles Computer Science Department MEMO-F524 Masters

   thesis An Efficient and Parallel Abstract Interpreter in Scala — 3×3 Parallel Implementations — Olivier Pirson — opi@opimedia.be orcid.org/0000-0001-6296-9659 March 22, 2019 (Last modifications: June 18, 2020) https://speakerdeck.com/opimedia/ efficient-parallel-abstract-interpreter-in-scala-3x3-implementations Vrije Universiteit Brussel Promotors Coen De Roover Wolfgang De Meuter Advisor Quentin Sti´ evenart

2. An Efficient and Parallel Abstract Interpreter in Scala — 3×3

   Parallel Implementations The problematic Sequential algorithm Parallel algorithms Results Todo 1 The problematic: How to prove properties in reasonable time? 2 Sequential algorithm 3 Parallel algorithms 4 Results 5 Todo An Efficient and Parallel Abstract Interpreter in Scala — 3×3 Parallel Implementations 2 / 22

3. An Efficient and Parallel Abstract Interpreter in Scala — 3×3

   Parallel Implementations The problematic Sequential algorithm Parallel algorithms Results Todo From undecidable problem to fast decidable technique We want prove properties about programs. But it is an undecidable problem. ↓ Abstract interpretation is a static analysis technique that evaluates abstraction of programs. Decidable but high time complexity. ↓ A possible way to make that faster is to parallelize. . . An Efficient and Parallel Abstract Interpreter in Scala — 3×3 Parallel Implementations 3 / 22

4. An Efficient and Parallel Abstract Interpreter in Scala — 3×3

   Parallel Implementations The problematic Sequential algorithm Parallel algorithms Results Todo Parallelization of Scala-AM Scala-AM “(Abstract) Abstract Machine Experiments using Scala” (forked around September 14, 2017) ↓ Restriction to the simplest abstract machine (AAM), without optimization Restriction to analyze only Scheme programs. ↓ 3×3 parallel implementations (ParAAM∗) with actors (Akka) ↓ Scala-Par-AM https://bitbucket.org/OPiMedia/scala-par-am/ An Efficient and Parallel Abstract Interpreter in Scala — 3×3 Parallel Implementations 4 / 22

5. An Efficient and Parallel Abstract Interpreter in Scala — 3×3

   Parallel Implementations The problematic Sequential algorithm Parallel algorithms Results Todo 1 The problematic: How to prove properties in reasonable time? 2 Sequential algorithm 3 Parallel algorithms 4 Results 5 Todo An Efficient and Parallel Abstract Interpreter in Scala — 3×3 Parallel Implementations 5 / 22

6. An Efficient and Parallel Abstract Interpreter in Scala — 3×3

   Parallel Implementations The problematic Sequential algorithm Parallel algorithms Results Todo Worklist and step function, walk over the state graph (letrec ((abs (lambda (x) (if (>= x 0) x (- x))))) (abs -42)) initial state (abs -42) step function (if (>= x 0) x (- x)) (>= x 0) ko(Bool) x (- x) ko(Int) ( Ò ( × x ) ( (>= x 0) x (− x ) ) ) ( × −42) # state: 8 # final value: 1 (Int) # already visited: 1 Worklist max size: 2 Sizes of successors: # size 1: 6 # size 2: 1 Essential parts of abstract interpretation for this presentation: main loop on a worklist of states the step function: takes a state and returns a set of states Sequential algorithm (Scala code of SeqAAM) w o r k l i s t = empty l i s t v i s i t e d = empty s e t w o r k l i s t = w o r k l i s t ∪ { i n i t i a l s t a t e } Ö Ô Ø s t a t e = p i c k one from w o r k l i s t s t a t e not i n v i s i t e d Ø Ò v i s i t e d = v i s i t e d ∪ { s t a t e } e v a l u a t i o n of s t a t e (essentially s u c c e s s o r s = ste p ( s t a t e )) w o r k l i s t = w o r k l i s t ∪ s u c c e s s o r s other update (final values. . . ) ÙÒØ Ð w o r k l i s t i s empty The completed state graph does not depend of the order of the evaluation. Crucial for parallelization. An Efficient and Parallel Abstract Interpreter in Scala — 3×3 Parallel Implementations 6 / 22

7. An Efficient and Parallel Abstract Interpreter in Scala — 3×3

   Parallel Implementations The problematic Sequential algorithm Parallel algorithms Results Todo Very simple Scheme example, bigger state graph (letrec ((fibonacci (lambda (n) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2))))))) (fibonacci 10)) (fibonacci 10) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) (<= n 1) ko(Bool) n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) ko(Int) (fibonacci (- n 1)) (- n 1) ko(Int) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) (<= n 1) ko(Bool) n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) ko(Int) (fibonacci (- n 1)) ko(Int) (fibonacci (- n 1)) (- n 1) (fibonacci (- n 2)) (- n 1) ko(Int) (- n 2) ko(Int) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) ko(Int) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) (<= n 1) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) (<= n 1) ko(Bool) n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) ko(Bool) n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) n n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) (+ (fibonacci (- n 1)) (fibonacci (- n 2))) ko(Int) ko(Int) (fibonacci (- n 2)) (fibonacci (- n 2)) ko(Int) (fibonacci (- n 1)) ko(Int) ko(Int) (fibonacci (- n 1)) (fibonacci (- n 1)) (- n 1) (fibonacci (- n 2)) (- n 1) (- n 1) (- n 2) (- n 2) ko(Int) ko(Int) ko(Int) ko(Int) (- n 2) ko(Int) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) ko(Int) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) (<= n 1) (<= n 1) (<= n 1) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) ko(Bool) ko(Bool) ko(Bool) n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) (+ (fibonacci (- n 1)) (fibonacci (- n 2))) (+ (fibonacci (- n 1)) (fibonacci (- n 2))) n n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) (+ (fibonacci (- n 1)) (fibonacci (- n 2))) n n ko(Int) (fibonacci (- n 1)) ko(Int) ko(Int) ko(Int) (fibonacci (- n 1)) (fibonacci (- n 1)) ko(Int) ko(Int) ko(Int) ko(Int) ko(Int) (- n 1) (fibonacci (- n 2)) (fibonacci (- n 2)) (- n 1) (- n 1) (fibonacci (- n 2)) (fibonacci (- n 2)) (fibonacci (- n 2)) (- n 2) (- n 2) ko(Int) (- n 2) (- n 2) ko(Int) ko(Int) (- n 2) ko(Int) ko(Int) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) ko(Int) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) ko(Int) ko(Int) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) (<= n 1) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) (<= n 1) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) (<= n 1) ko(Bool) ko(Bool) (<= n 1) ko(Bool) (+ (fibonacci (- n 1)) (fibonacci (- n 2))) (+ (fibonacci (- n 1)) (fibonacci (- n 2))) n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) n n n n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) (+ (fibonacci (- n 1)) (fibonacci (- n 2))) n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) ko(Bool) n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) ko(Int) ko(Int) ko(Int) ko(Int) ko(Int) ko(Int) n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) (+ (fibonacci (- n 1)) (fibonacci (- n 2))) n ko(Int) (fibonacci (- n 1)) ko(Int) (fibonacci (- n 1)) ko(Int) (fibonacci (- n 2)) (fibonacci (- n 2)) (fibonacci (- n 2)) (fibonacci (- n 2)) (fibonacci (- n 2)) ko(Int) (fibonacci (- n 1)) ko(Int) (fibonacci (- n 1)) ko(Int) (- n 1) (- n 1) (- n 2) (- n 2) (- n 2) (- n 2) (- n 2) (- n 1) (- n 1) ko(Int) ko(Int) ko(Int) ko(Int) ko(Int) ko(Int) ko(Int) ko(Int) ko(Int) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) (<= n 1) (<= n 1) (<= n 1) ko(Bool) ko(Bool) ko(Bool) n n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) (+ (fibonacci (- n 1)) (fibonacci (- n 2))) (+ (fibonacci (- n 1)) (fibonacci (- n 2))) (+ (fibonacci (- n 1)) (fibonacci (- n 2))) n n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) n n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) (+ (fibonacci (- n 1)) (fibonacci (- n 2))) (+ (fibonacci (- n 1)) (fibonacci (- n 2))) n n ko(Int) (fibonacci (- n 1)) ko(Int) ko(Int) ko(Int) ko(Int) ko(Int) ko(Int) ko(Int) ko(Int) (fibonacci (- n 2)) (- n 1) (- n 2) ko(Int) ko(Int) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) (<= n 1) ko(Bool) (+ (fibonacci (- n 1)) (fibonacci (- n 2))) n n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) n (+ (fibonacci (- n 1)) (fibonacci (- n 2))) (fibonacci (- n 1)) ko(Int) ko(Int) ko(Int) (- n 1) ko(Int) (if (<= n 1) n (+ (fibonacci (- n 1)) (fibonacci (- n 2)))) ( Ò ( f i b o n a c c i n ) ( (<= n 1) n (+ ( f i b o n a c c i (− n 1)) ( f i b o n a c c i (− n 2 ) ) ) ) ) ( f i b o n a c c i 10) # state: 276 # final value: 1 (Int) # already visited: 71 Worklist max size: 24 Sizes of successors: # size 1: 231 # size 2: 13 # size 3: 3 # size 4: 2 # size 6: 12 An Efficient and Parallel Abstract Interpreter in Scala — 3×3 Parallel Implementations 7 / 22

8. An Efficient and Parallel Abstract Interpreter in Scala — 3×3

   Parallel Implementations The problematic Sequential algorithm Parallel algorithms Results Todo Worklist implementations Possible (immutable) data structures to implement the worklist (tested on Sergey/jfp/primtest.scm) • list of states 2.304s (Scala code of SeqAAM) s s s s s s • set of states 2.466s (Scala code of SeqAAMS) s s s s s s • list of sets of states 2.315s (Scala code of SeqAAMLS) s s s s s s avoid useless concatenations Each set corresponds to a result of the step function. Selected for parallel implementations and SeqAAMLS becomes the reference for comparisons. These time results and following are averages on 10 repetitions (after 3 repetitions skipped), made on Intel Xeon Gold 6148 2.40GHz, 20 cores available (VUB Hydra cluster), with Scala 2.12.7 – Akka 2.5.21 – Java 1.8.0 – GraalVM 1.0.0-rc14. An Efficient and Parallel Abstract Interpreter in Scala — 3×3 Parallel Implementations 8 / 22

9. An Efficient and Parallel Abstract Interpreter in Scala — 3×3

   Parallel Implementations The problematic Sequential algorithm Parallel algorithms Results Todo 1 The problematic: How to prove properties in reasonable time? 2 Sequential algorithm 3 Parallel algorithms 4 Results 5 Todo An Efficient and Parallel Abstract Interpreter in Scala — 3×3 Parallel Implementations 9 / 22

10. An Efficient and Parallel Abstract Interpreter in Scala — 3×3

    Parallel Implementations The problematic Sequential algorithm Parallel algorithms Results Todo First parallel implementation: ParAAM-L-SA-state main thread SenderAggregator N = p − 1 Eval actors w o r k l i s t = empty l i s t v i s i t e d = empty s e t shared data w o r k l i s t = w o r k l i s t ∪{ i n i t i a l s t a t e } Ö Ô Ø send c u r r e n t w o r k l i s t wait r e c e i v e new w o r k l i s t ÙÒØ Ð w o r k l i s t i s empty ÓÖ s t a t e from c u r r e n t w o r k l i s t send s t a t e update N r e c e i v e d send f i n i s h e d e v a l u a t e s t a t e send r e s u l t s to Eval n◦ i%N I name this implementation ParAAM-L-SA-state, for ParAAM – Loop – SenderAggregator – state. An Efficient and Parallel Abstract Interpreter in Scala — 3×3 Parallel Implementations 10 / 22

11. An Efficient and Parallel Abstract Interpreter in Scala — 3×3

    Parallel Implementations The problematic Sequential algorithm Parallel algorithms Results Todo First alternative: ParAAM-L-SA-set main thread SenderAggregator N = p − 1 Eval actors w o r k l i s t = empty l i s t v i s i t e d = empty s e t shared data w o r k l i s t = w o r k l i s t ∪{ i n i t i a l s t a t e } Ö Ô Ø send c u r r e n t w o r k l i s t wait r e c e i v e new w o r k l i s t ÙÒØ Ð w o r k l i s t i s empty f o r e a c h s e t from c u r r e n t w o r k l i s t send s e t update N r e c e i v e d send f i n i s h e d f o r e a c h s t a t e from s e t e v a l u a t e s t a t e send r e s u l t s to Eval n◦ i%N First improvement: send more than one state at a time. Set a set of states. ParAAM-L-SA-set, for ParAAM – Loop – SenderAggregator – set. An Efficient and Parallel Abstract Interpreter in Scala — 3×3 Parallel Implementations 11 / 22

12. An Efficient and Parallel Abstract Interpreter in Scala — 3×3

    Parallel Implementations The problematic Sequential algorithm Parallel algorithms Results Todo Second alternative: ParAAM-L-SA-part main thread SenderAggregator N = p − 1 Eval actors w o r k l i s t = empty l i s t v i s i t e d = empty s e t shared data w o r k l i s t = w o r k l i s t ∪{ i n i t i a l s t a t e } Ö Ô Ø send c u r r e n t w o r k l i s t wait r e c e i v e new w o r k l i s t ÙÒØ Ð w o r k l i s t i s empty f o r e a c h e qual part from c u r r e n t w o r k l i s t send part update N r e c e i v e d send f i n i s h e d f o r e a c h s t a t e from part e v a l u a t e s t a t e send r e s u l t s to Eval n◦ i Other possibility: send “equals” part of the worklist. ParAAM-L-SA-part, for ParAAM – Loop – SenderAggregator – part. An Efficient and Parallel Abstract Interpreter in Scala — 3×3 Parallel Implementations 12 / 22

13. An Efficient and Parallel Abstract Interpreter in Scala — 3×3

    Parallel Implementations The problematic Sequential algorithm Parallel algorithms Results Todo 3×3 parallel implementations ParAAM-L-SA-state ParAAM-C-S-state ParAAM-C-state state SeqAAMLS ParAAM-L-SA-set ParAAM-C-S-set ParAAM-C-set set ParAAM-L-SA-part ParAAM-C-S-part ParAAM-C-part part L-SA C-S C Loop – SenderAggregator Concurrent – Sender Concurrent 1 special actor p-1 eval actors main loop (with a barrier) SA send worklist each eval actor send results to SA 1 special actor p-1 eval actors no barrier S send worklist each eval actor update 0 special actor p eval actors no barrier each eval actor send worklist each eval actor update An Efficient and Parallel Abstract Interpreter in Scala — 3×3 Parallel Implementations 13 / 22

14. An Efficient and Parallel Abstract Interpreter in Scala — 3×3

    Parallel Implementations The problematic Sequential algorithm Parallel algorithms Results Todo Other strategy: ParAAM-C-S-state main thread Sender N = p − 1 Eval actors w o r k l i s t = empty l i s t v i s i t e d = empty s e t shared data send s t a r t wait send i n i t i a l s t a t e ÓÖ ( state , a c t o r ) from c u r r e n t w o r k l i s t and a v a i l a b l e Eval a c t o r s send s t a t e to a c t o r w o r k l i s t i s empty and a l l Eval a c t o r s a v a i l a b l e send f i n i s h e d e v a l u a t e s t a t e update (with synchronization) send a v a i l a b l e to Eval n◦ 0 Eval n◦ i available I name this implementation ParAAM-C-S-state, for ParAAM – Concurrent – Sender – state. And these similar improvements: ParAAM-C-S-set, for ParAAM – Concurrent – Sender – set and ParAAM-C-S-part, for ParAAM – Concurrent – Sender – part. An Efficient and Parallel Abstract Interpreter in Scala — 3×3 Parallel Implementations 14 / 22

15. An Efficient and Parallel Abstract Interpreter in Scala — 3×3

    Parallel Implementations The problematic Sequential algorithm Parallel algorithms Results Todo Last strategy: ParAAM-C-state main thread N = p Eval actors v i s i t e d = empty s e t a c t o r s = empty l i s t shared data send s t a r t wait send i n i t i a l s t a t e e v a l u a t e s t a t e update (with synchronization) ÓÖ ( state , a c t o r ) from c u r r e n t w o r k l i s t and a v a i l a b l e Eval a c t o r s send s t a t e to a c t o r w o r k l i s t i s empty and a l l Eval a c t o r s a v a i l a b l e send f i n i s h e d I name this implementation ParAAM-C-state, for ParAAM – Concurrent – state. And these similar improvements: ParAAM-C-set, for ParAAM – Concurrent – set and ParAAM-C-part, for ParAAM – Concurrent – part. An Efficient and Parallel Abstract Interpreter in Scala — 3×3 Parallel Implementations 15 / 22

16. An Efficient and Parallel Abstract Interpreter in Scala — 3×3

    Parallel Implementations The problematic Sequential algorithm Parallel algorithms Results Todo 1 The problematic: How to prove properties in reasonable time? 2 Sequential algorithm 3 Parallel algorithms 4 Results 5 Todo An Efficient and Parallel Abstract Interpreter in Scala — 3×3 Parallel Implementations 16 / 22

17. An Efficient and Parallel Abstract Interpreter in Scala — 3×3

    Parallel Implementations The problematic Sequential algorithm Parallel algorithms Results Todo Computation time of all implementations 0 2 4 6 8 10 12 0 2 4 6 8 10 12 14 16 18 20 time (seconds) p SeqAAMLS ParAAM-L-SA-state ParAAM-L-SA-set ParAAM-L-SA-part ParAAM-C-S-state ParAAM-C-S-set ParAAM-C-S-part ParAAM-C-state ParAAM-C-set ParAAM-C-part Results computed on Sergey/jfp/primtest.scm Statistic computed with SeqAAMLS # state: 243472 # final: 1 (Int) # error: 1 # already visited: 48430 Worklist max size: 5646 Max sizes of successors: 6 An Efficient and Parallel Abstract Interpreter in Scala — 3×3 Parallel Implementations 17 / 22

18. An Efficient and Parallel Abstract Interpreter in Scala — 3×3

    Parallel Implementations The problematic Sequential algorithm Parallel algorithms Results Todo Speedup 0 2 4 6 8 10 0 2 4 6 8 10 12 14 16 18 20 speedup p 0 0.5 1 1.5 2 2.5 3 0 2 4 6 8 10 12 14 16 18 20 time (seconds) p SeqAAMLS ParAAM-L-SA-state ParAAM-L-SA-set ParAAM-L-SA-part ParAAM-C-S-state ParAAM-C-S-set ParAAM-C-S-part ParAAM-C-state ParAAM-C-set ParAAM-C-part speedup = time of SeqAAMLS time (Super-linear speedup is unexplained for now!) An Efficient and Parallel Abstract Interpreter in Scala — 3×3 Parallel Implementations 18 / 22

19. An Efficient and Parallel Abstract Interpreter in Scala — 3×3

    Parallel Implementations The problematic Sequential algorithm Parallel algorithms Results Todo Efficiency 0 0.2 2 ¡ 2 ¢ 2 £ 1 ¤ ¥ ¤ ¡ 0 2 4 6 8 10 12 14 16 18 20 effiency p 0 2 4 6 8 10 0 2 4 6 8 10 12 14 16 18 20 speedup p SeqAAMLS ParAAM-L-SA-state ParAAM-L-SA-set ParAAM-L-SA-part ParAAM-C-S-state ParAAM-C-S-set ParAAM-C-S-part ParAAM-C-state ParAAM-C-set ParAAM-C-part efficiency = speedup p An Efficient and Parallel Abstract Interpreter in Scala — 3×3 Parallel Implementations 19 / 22

20. An Efficient and Parallel Abstract Interpreter in Scala — 3×3

    Parallel Implementations The problematic Sequential algorithm Parallel algorithms Results Todo 1 The problematic: How to prove properties in reasonable time? 2 Sequential algorithm 3 Parallel algorithms 4 Results 5 Todo An Efficient and Parallel Abstract Interpreter in Scala — 3×3 Parallel Implementations 20 / 22

21. An Efficient and Parallel Abstract Interpreter in Scala — 3×3

    Parallel Implementations The problematic Sequential algorithm Parallel algorithms Results Todo Done / Todo Implementation is (almost) done (Need little checkings, and maybe change the update of visited set for the worst implementations.) Todo Select which Scheme examples to use to produce final benchmarks and estimate computation times Run computations and collect data (benchmarks and some statistics) Sort data and finalize analyzes Write and write again (some parts of theoretical background can be taken from preparatory work) An Efficient and Parallel Abstract Interpreter in Scala — 3×3 Parallel Implementations 21 / 22

22. An Efficient and Parallel Abstract Interpreter in Scala — 3×3

    Parallel Implementations The problematic Sequential algorithm Parallel algorithms Results Todo Thank you! Questions time. . . Implementation: Scala-Par-AM – https:// Ø Ù ØºÓÖ »ÇÈ Å /scala-par-am/ This presentation on https://×Ô Ö º ÓÑ»ÓÔ Ñ / efficient-parallel-abstract-interpreter-in-scala-3x3-implementations Document, L A TEX sources, other references and previous presentations on https://bitbucket.org/OPiMedia/efficient-parallel-abstract-interpreter-in-scala An Efficient and Parallel Abstract Interpreter in Scala — 3×3 Parallel Implementations 22 / 22