Orchestration by Approximation Mapping Stream Programs onto Multicore Architectures S. M. Farhad (University of Sydney) Joint work with Yousun Ko Bernd Burgstaller Bernhard Scholz

2 Outline Motivation Research question Contributions Summary 2

3 Cores are the New Gates # cores/chip ( Shekhar Borkar, Intel) Courtesy: Scott’08 C/C++/Java CUDA X10 Peakstream Fortress Accelerator Ct C T M Rstream Rapidmind Stream Programming 3

4 Stream Programming Paradigm Programs expressed as stream graphs  Streams: Sequence of data elements  Actor: Functions applied to streams 4 Actor/Filter Streams

5 StreamIt Language Basic and hierarchical structures Each construct has single input/output stream parallel computation may be any StreamIt language construct joiner splitter pipeline feedback loop joiner splitter splitjoin filter 5

6 Outline Motivation Research question Contributions Summary 6

7 How to Orchestrate a Stream Graph? Mapping actors Eliminate bottlenecks (aka. hot actors) 7

Mapping Actors 8 B 60 C D 5 5 A Core 1Core 2Core 3 5 A D 5 B 60 C Load=10Load=60 Make span = 60, Speedup = 130/60 = 2.17 Ideally speedup = 3 Actors B and C are the bottlenecks

Bottlenecks Elimination 9 B 60 C D 5 5 A D 15 A B_ s1 6 j1 B_2 60 B_3 60 C_ s2 6 j2 C_2 60 C_3 60 Hot actor duplication Core 1 Core 2 Core 3 15 A s1 6 B_1 60 C_1 60 B_2 60 j1 6 s2 6 C_2 60 j2 6 B_3 60 C_3 60 D 15 Load = 141Load = 138Load = 135 Make span = 141, Speedup = 130x3/141 = % increased speedup

10 Orchestration of Stream Program Contd. Current state of the art  Integer Linear Programming Intractable  Heuristics Unknown performance How to find a fast and good solution?  Approximation algorithms that have Polynomial runtime Quality bound for solution 10

11 Outline Motivation Research question Contributions Summary 11

12 Data Transfer Model Arrival rate depends on the data rate of the actors (maximize) Data transfer model forms a system of sim. functional linear equation Compute a closed form of the output data rate We also consider a processor utilization function for each actor 12 ABC 1511 z

13 Bottleneck Analysis The arrival rate is limited by  Processor capacity of the cores  Memory bandwidth A quantitative analysis determines  An upper bound of the arrival rate imposed by an actor  An upper bound of the arrival rate imposed by the parallel system Hot actor  Upper bound (actor) < upper bound (system) 13

14 Approximation of Actor Allocation Problem The actor allocation problem (AAP) is NP-hard For a fixed arrival rate, the AAP reduces to standard bin-packing problem (closed form) There exist approximation algorithms for bin- packing  Polynomial running time  Solution quality is bounded

15 Summary (ASPLOS 2011) Novel data transfer model A simple quantitative analysis to detect and eliminate bottlenecks A novel 2-approximation algorithm for deploying stream graphs on multicore platforms Results are within 5% of the optimal solution Achieves a geometric mean speedup of 6.95x for 8 processors over single processor execution 15

16 Related Works [1] Static Scheduling of SDF Programs for DSP [IEEE ’87] [2] StreamIt: A language for streaming applications [Springer ‘02] [3] Phased Scheduling of Stream Programs [LCTES ’03] [4] Exploiting Coarse Grained Task, Data, and Pipeline Parallelism in Stream Programs [ASPLOS ‘06] [5] Orchestrating the Execution of Stream Programs on Cell [PLDI ’08] [6] Software Pipelined Execution of Stream Programs on GPUs [IEEE ‘09] [7] Synergistic Execution of Stream Programs on Multicores with Accelerators [IEEE ‘09] [8] An empirical characterization of stream programs and its implications for language and compiler design [PACT ’10] 16

Questions?

18 Focus of Our Work Stream Graph Scheduling Stream Graph Partitioning Layout on Target Architecture Communication Scheduling Linear Functional Equation Solver Actor Allocation on Processors Bottleneck Resolver StreamIt Compiler Phases

19 Actor Allocation Constraint % Actors with their utilizations Each core has 100% utilization n 2 1 n 5 2 3

20 Binary Search 20 0ub(z) 1.0 Solution space rightleftmid Allocation possible?

21 Binary Search 21 0ub(z) 1.0 rightleft Allocation possible? mid 21

22 Binary Search 22 0ub(z) 1.0 rightleft Allocation possible? mid 22

23 Actor Allocation of Bottleneck Free Program 23 D 5 5 A B_ s1 B_2 20 B_3 20 C_ j1 C_2 20 C_3 20 Core 1 5 A B_1 20 C_1 20 Core 2 s1 2 B_2 20 j1 2 C_2 20 Core 3 B_3 20 C_3 20 D 5 Load = 45Load = 44Load = 45 Make span = 45, Speedup = 130/45 = 2.89 Mapping Efficient Bottleneck Resolving

24 Experiments Our method implemented as an extension of StreamIt compiler We compare to ILP based method [Scott 08] (solved with CPLEX) Hardware Setup  2.33GHz dual quad-core Intel Xeon processors 16GB memory Linux kernel version  Profiler uses the x86-64’s hardware cycle counters 24

25 Experiments Contd. Experimental Process  Profiling  Computing closed form  Resolve bottlenecks  Compute the mapping  Compute the layout scheduling  Invoke the StreamIt back end  Finally we measure the performance 25

26 Experiments Contd. Benchmark ActorsStateful DCT2218 FMRadio6723 TDE5527 FFT2614 MergeSort312 FilterBankNew5334 RadixSort132 EqualizerProgram6522 BitonicSort4522 DES MPEG397 MatrixMult522 26

27 Experimental Results for 2 – 4 Processors BenchmarkProc# ILP Time (Optimal)(s) DCT FMRadio TDE FFT Our method’s run time: <1s BenchmarkProc# ILP Time (Optimal)(s) Equalizer BitonicSort DES MPEG

28 Experimental Results for 2 – 4 Processors BenchmarkProc# Arrival rate ratio (Appx/Optimal) Apx. Arrival Rate (MBps) DCT FMRadio TDE FFT BenchmarkProc# Arrival rate ratio (Appx/Optimal) Apx. Arrival Rate (MBps) Equalizer BitonicSort DES MPEG

29 Speedup Results 29

30 Summary Approximation algorithm for solving actor allocation problem Data rate transfer model that resolves bottlenecks We separate the bottleneck elimination from the actor allocation We implemented our approach and compared with an optimal approach Optimal approach has unpredictable time Our approach has negligible time for all benchmarks Quality of our approach is at most 5% off the optimum For up to 8 processors we achieve a geometric mean speedup of 6.95x over single processor execution 30

Questions?