Compiling for Concise Code and Efficient I/O

Transcription

1 Compiling for Concise Code and Efficient I/O Sebastian Ertel, Andrés Goens, Justus Adam and Jeronimo Castrillon Chair for Compiler Construction TU Dresden 27th International Conference on Compiler Construction Vienna,

2 Microservice-based Architectures Backend (server) system requirements: scalable, flexible, fault-tolerant 2

3 Microservice-based Architectures Backend (server) system requirements: scalable, flexible, fault-tolerant [ Monolithic server 3

4 Microservice-based Architectures Backend (server) system requirements: scalable, flexible, fault-tolerant [ Monolithic server Microservice: independent function Microservices compose to larger services 4

5 Microservice-based Architectures Backend (server) system requirements: scalable, flexible, fault-tolerant [ Monolithic server [Source: I Love APIs 2015 by Chris Munns, licensed under CC BY 4.0, available at: h p://bit.ly/2zbohtk] Microservice: independent function Microservices compose to larger services 5

6 Microservice-based Architectures Backend (server) system requirements: scalable, flexible, fault-tolerant Cost: Lots of I/O! [ Monolithic server [Source: I Love APIs 2015 by Chris Munns, licensed under CC BY 4.0, available at: h p://bit.ly/2zbohtk] Microservice: independent function Microservices compose to larger services 6

7 Fighting I/O Efficient I/O Concise Code 7

8 Fighting I/O Efficient I/O Batching (& deduplication): 1 I/O call vs. n I/O calls Concise Code 2500 latency [ms] batched sequential # blog posts Concurrency: Computation IO Computation (Caching) 8

9 Fighting I/O 2500 Efficient I/O Batching (& deduplication): 1 I/O call vs. n I/O calls group I/O calls Concise Code Breaks modularity! latency [ms] batched sequential # blog posts Concurrency: Computation IO Computation (Caching) 9

10 Fighting I/O 2500 Efficient I/O Batching (& deduplication): 1 I/O call vs. n I/O calls group I/O calls Concise Code Breaks modularity! latency [ms] # blog posts batched sequential Concurrency: Computation IO Computation (Caching) split up code (e.g. into threads) Introduces optimization aspect (concurrency) into the algorithm! 10

11 Fighting I/O 2500 Efficient I/O Batching (& deduplication): 1 I/O call vs. n I/O calls group I/O calls Concise Code Breaks modularity! latency [ms] # blog posts batched sequential Concurrency: Computation IO Computation (Caching) split up code (e.g. into threads) Batching and concurrency do not easily compose! Introduces optimization aspect (concurrency) into the algorithm! 11

12 Fighting I/O 2500 Efficient I/O Batching (& deduplication): 1 I/O call vs. n I/O calls group I/O calls Concise Code Breaks modularity! latency [ms] batched Release the developer from this burden Compiler-based Approach! sequential # blog posts Concurrency: Computation IO Computation (Caching) split up code (e.g. into threads) Batching and concurrency do not easily compose! Introduces optimization aspect (concurrency) into the algorithm! 12

13 Ÿauhau - A compiler framework for microservices DSL (for microservices) unoptimized I/O reduction Expression IR (ƛ-calcus-based) lower I/O concurrency Dataflow IR (concurrent) I/O optimized Dataflow Representation 13

14 Ÿauhau - A compiler framework for microservices DSL (for microservices) unoptimized I/O reduction Expression IR (ƛ-calcus-based) lower I/O concurrency Dataflow IR (concurrent) I/O optimized Dataflow Representation Provably semanticpreserving transformations Concurrency (almost) for free 14

15 A minimalistic DSL for microservices DSL (for microservices) unoptimized I/O reduction Expression IR (ƛ-calcus-based) lower I/O concurrency Dataflow IR (concurrent) I/O optimized Dataflow Representation t ::= v ƛv.t t t let v=t in t if (t t t) ff f (x 1 x n ) io(x) map(ƛv.t [v 1 v n ]) 15

16 Semantic-preserving Transformations DSL (for microservices) unoptimized I/O reduction Expression IR (ƛ-calcus-based) lower I/O concurrency Dataflow IR (concurrent) I/O optimized Dataflow Representation t ::= v ƛv.t t t let v=t in t if (t t t) ff f (x 1 x n ) io(x) Disclaimer: Presentation diverges from paper for visualization purposes. Data flow graphs before and after the transformations instead of map(ƛv.t [v 1 v n ]) lambda expressions. 16

17 Semantic-preserving Transformations DSL (for microservices) unoptimized I/O reduction Expression IR (ƛ-calcus-based) lower I/O concurrency Dataflow IR (concurrent) I/O optimized Dataflow Representation t ::= v ƛv.t t t let v=t in t if (t t t) ff f (x 1 x n ) io(x) ff Grouping independent I/O calls: req io io io ff req io!ff req map(ƛv.t [v 1 v n ]) 17

18 Semantic-preserving Transformations DSL (for microservices) unoptimized I/O reduction Expression IR (ƛ-calcus-based) lower I/O concurrency Dataflow IR (concurrent) I/O optimized Dataflow Representation t ::= v ƛv.t t t let v=t in t if (t t t) ff f (x 1 x n ) io(x) ff Grouping independent I/O calls: req io io io ff req io!ff req map(ƛv.t [v 1 v n ]) 18

19 Semantic-preserving Transformations DSL (for microservices) unoptimized I/O reduction Expression IR (ƛ-calcus-based) lower I/O concurrency Dataflow IR (concurrent) I/O optimized Dataflow Representation t ::= v ƛv.t t t let v=t in t if (t t t) ff f (x 1 x n ) io(x) Grouping independent I/O calls: Lifting I/O calls: io io ff req io [v 1 v n ] map t io t pam [req t ff 1 req n ] [rsp 1 rsp n ] map req pam map io pam map t io!ff req pam map(ƛv.t [v 1 v n ]) 19

20 Semantic-preserving Transformations DSL (for microservices) unoptimized I/O reduction Expression IR (ƛ-calcus-based) lower I/O concurrency Dataflow IR (concurrent) I/O optimized Dataflow Representation t ::= v ƛv.t t t let v=t in t if (t t t) ff f (x 1 x n ) io(x) Grouping independent I/O calls: Lifting I/O calls: io io ff req io [v 1 v n ] map t io t pam [req t ff 1 req n ] [rsp 1 rsp n ] map req pam map io pam map t io!ff req pam map(ƛv.t [v 1 v n ]) 20

21 Semantic-preserving Transformations DSL (for microservices) unoptimized I/O reduction Expression IR (ƛ-calcus-based) lower I/O concurrency Dataflow IR (concurrent) I/O optimized Dataflow Representation t ::= v ƛv.t t t let v=t in t if (t t t) ff f (x 1 x n ) io(x) Grouping independent I/O calls: Lifting I/O calls: io io ff req io [v 1 v n ] map t io t pam [req 1 req n ] [rsp 1 rsp n ] map t pam ff req io!ff req map t io!ff req pam map(ƛv.t [v 1 v n ]) 21

22 Semantic-preserving Transformations DSL (for microservices) unoptimized I/O reduction Expression IR (ƛ-calcus-based) lower I/O concurrency Dataflow IR (concurrent) I/O optimized Dataflow Representation t ::= v ƛv.t t t let v=t in t if (t t t) ff f (x 1 x n ) io(x) map(ƛv.t [v 1 v n ]) Grouping independent I/O calls: Lifting I/O calls: io io ff req io io [v 1 v n ] map t io t pam [req 1 req n ] [rsp 1 rsp n ] map t pam ff req io!ff req map t condition t io t t t if fi if fi io if t io t t t!ff req pam fi 22

23 Semantic-preserving Transformations DSL (for microservices) unoptimized I/O reduction Expression IR (ƛ-calcus-based) lower I/O concurrency Dataflow IR (concurrent) I/O optimized Dataflow Representation t ::= v ƛv.t t t let v=t in t if (t t t) ff f (x 1 x n ) io(x) map(ƛv.t [v 1 v n ]) Grouping independent I/O calls: Lifting I/O calls: io io ff req io io [v 1 v n ] map t io t pam [req 1 req n ] [rsp 1 rsp n ] map t pam ff req io!ff req map t condition t io t t t if fi if fi io if t io t t t!ff req pam fi 23

24 Bringing back Concurrency DSL (for microservices) unoptimized I/O reduction Expression IR (ƛ-calcus-based) lower I/O concurrency Dataflow IR (concurrent) I/O optimized Dataflow Representation Computation IO IO IO IO Computation 24

25 Bringing back Concurrency DSL (for microservices) unoptimized I/O reduction Expression IR (ƛ-calcus-based) lower I/O concurrency Dataflow IR (concurrent) I/O optimized Dataflow Representation Computation IO [ req src 1 req src m ] io [ src 1 rsp src m rsp]!ff req IO IO ds io src 1 dm [ src 1 rsp src m rsp]!ff req io src m IO Computation ds io src 1 io src m src 1 rsp src m rsp!ff req 25

26 Bringing back Concurrency DSL (for microservices) unoptimized I/O reduction Expression IR (ƛ-calcus-based) lower I/O concurrency Dataflow IR (concurrent) I/O optimized Dataflow Representation Computation IO [ req src 1 req src m ] io [ src 1 rsp src m rsp]!ff req IO IO ds io src 1 dm [ src 1 rsp src m rsp]!ff req io src m IO Computation ds io src 1 io src m src 1 rsp src m rsp!ff req 26

27 Bringing back Concurrency DSL (for microservices) unoptimized I/O reduction Expression IR (ƛ-calcus-based) lower I/O concurrency Dataflow IR (concurrent) I/O optimized Dataflow Representation Computation IO [ req src 1 req src m ] io [ src 1 rsp src m rsp]!ff req IO IO ds io src 1 io src m dm [ src 1 rsp src m rsp]!ff req io src 1!ff IO Computation ds req io src m src 1 rsp src m rsp 27

28 Use Case: Blog blog leftpane topics popularposts mainpane data dependency I/O group 3 I/O group 2 map io(req PostInfo ) map io(req PostContent ) io(req PostInfo ) map io(req PostViews ) map io(req PostContent ) map io(req PostInfo ) I/O group 1 io(req PostIds ) io(req PostIds ) io(req PostIds ) Version seq base batch full Time [ms] 275 ± ± ± ± 5.2 4x latency improvement! 28

29 Evaluation against State-of-the-art Haxl Facebook s Haskell-based approach on the abstraction of applicative functors. Muse Similar to Twitter s Stitch, Clojure-based implementation of an AST interpretation. Simon Marlow, Louis Brandy, Jonathan Coens, and Jon Purdy There is no fork: an abstraction for efficient, concurrent, and concise data access. ICFP 14. Alexey Kachayev Reinventing Haxl: Efficient, Concurrent and Concise Data Access. Presentation at EuroClojure

30 Got microservices for evaluation? Level-Graphs: level 0 subfunction level 1 x1 x2 req->io compute level 2 x3 level 3 x6 x4 x5 x7 Andrés Goens, Sebastian Ertel, Justus Adam, and Jeronimo Castrillon Level Graphs: Generating Benchmarks for Concurrency Optimizations in Compilers. MULTIPROG

31 Got microservices for evaluation? Level-Graphs: Programs: level 0 subfunction Haxl level 1 level 2 level 3 x6 x1 x2 x3 x4 x5 x7 req->io compute serialize Muse Seq Ÿauhau Andrés Goens, Sebastian Ertel, Justus Adam, and Jeronimo Castrillon Level Graphs: Generating Benchmarks for Concurrency Optimizations in Compilers. MULTIPROG

32 Ÿauhau outperforms State-of-the-art Level-Graphs: level 0 level 1 level 2 x1 x2 x3 level 3 x6 x4 x5 x7 subfunction req->io compute Programs: serialize Haxl Muse Seq Ÿauhau # I/O calls (avg.) haxl muse seq yauhau # graph levels Andrés Goens, Sebastian Ertel, Justus Adam, and Jeronimo Castrillon Level Graphs: Generating Benchmarks for Concurrency Optimizations in Compilers. MULTIPROG

33 Ÿauhau outperforms State-of-the-art Level-Graphs: Programs: level 0 level 1 level 2 x1 x2 x3 level 3 x6 x4 x5 x7 subfunction req->io compute haxl muse yauhau serialize Haxl Muse Seq Ÿauhau # I/O calls (avg.) haxl muse seq yauhau # graph levels haxl (fork) yauhau yauhau (conc I/O) # I/O calls (avg.) prob. of function/algorithm calls Andrés Goens, Sebastian Ertel, Justus Adam, and Jeronimo Castrillon Level Graphs: Generating Benchmarks for Concurrency Optimizations in Compilers. MULTIPROG Service latency [ms] # graph levels

34 Conclusion I/O optimizations performed at the compiler level Efficient I/O Concise Code Use lambda calculus to provide semantic-preserving transformations! Use dataflow for concurrency/parallel execution! Try it out: 34

35 Ÿauhau Code - Blog Use Case 35

36 Level Graphs Code Haxl (< GHC 8) Muse (with Cats) Ÿauhau 36