Zhelong Pan [1] This presentation as.pptx: (or scan QR code) The paper: [1] [2] Rudolf Eigenmann [2] 1

As.pptx: 2

« This is a cite from the paper. Note the dedicated quotation marks. » Any references are listed here. The paper: 3

4

5 Choose optimization options from above to maximize program performance. Good luck. The table is taken from page 5 of the original paper.

« Given a set of compiler optimization options {F 1, F 2,..., F n }, find the combination that minimizes the program execution time. Do this efficiently, without the use of a priori knowledge of the optimizations and their interactions. » 6

7

« We present […] Combined Elimination (CE), which aims at picking the best set of compiler optimizations for a program. […] this algorithm takes the shortest tuning time, while achieving comparable or better performance than other algorithms. » 8

9

 Exhaustive Search (ES)*  Batch Elimination (BE)  Iterative Elimination (IE)  Combined Elimination (CE)  Optimization Space Exploration (OSE)  Statistical Selection (SS)* * Not covered in detail 10

« 1.Get all 2 n combinations of n options F 1, F 2,..., F n. 2.Measure application execution time of the optimized version compiled under every possible combination. 3.The best version is the one with the least execution time. » « For 38 optimizations: It would take up to 2 38 program runs – a million years for a program that runs in two minutes. » COMPLEXITY: O(2 n ) 11

* Not to be confused with Rest In Peace RIP(F i ) > 0%: F i is actually useful RIP(F i ) < 0%: F i causes the program execution time to increase Not applying F i increases the runtime by RIP(F i ) → RIP(F i ) = 100% means the program runs twice as long without F i A measure for the usefulness of an optimization. 12

* Not to be confused with Rest In Peace = A measure for the usefulness of an optimization. 13 B:The baseline; a configuration of optimization options F i :An optimization option T B :Execution time when compiled under B T(F i =0):Execution time when compiled under B but with F i off

14 Baseline B:F 1 = 1, F 2 = 1, F 3 = 1 T B :80ms T(F 1 = 0):100ms (F 1 = 0, F 2 = 1, F 3 = 1)

« 1.Compile the application under the baseline B = {F 1 = 1, F 2 = 1,..., F n = 1}. Execute the generated code version to get the baseline execution time T B. 2.For each optimization F i, switch it off from B and compile the application. Execute the generated version to get T(F i = 0), and compute the RIP B (F i = 0). 3.Disable all optimizations with negative RIPs to generate the final, tuned version. » Would be good if the optimizations did not affect each other. COMPLEXITY: O(n) 15

16 Would be good if the optimizations did not affect each other. COMPLEXITY: O(n) F 1, F 2,..., F n Compile w/ all-on Execute For each F i Compile with all-on except F i ExecuteT(F i = 0) TBTB RIP B (F i = 0) Yes: Don’t use F i No: Use F i RIP B (F i = 0) < 0?

CombinationF1F1 F2F2 RuntimeRIP B 1OFF 320 ms60% 2ONOFF160 ms-20% 3OFFON180 ms-10% 4ON 200 ms(0%) TBTB 17

COMPLEXITY: O(n 2 ) « [...] IE achieves better program performance than BE, since it considers the interaction of optimizations. However, when the interactions have only small effects, BE may perform close to IE in a faster way. » 1.Initialize S = {F 1, F 2,..., F n } and B = {F 1 = 1, F 2 = 1,..., F n = 1} 2.Determine the baseline T B : Compile the program with the options in B and measure its runtime. 3.For each optimization F i in S, compute RIP B (F i ) by compiling the program with the options in B, except F i which is turned off, and measuring its runtime. 4.Find the optimization F j with the most negative RIP b, remove it from S and set F j = 0 in B (The baseline changes!) 5.Repeat until all remaining optimizations have a positive RIP b. B now contains the "optimal" options. 18

19 F 1, F 2,..., F n Compile w/ B Execute Compile under B, but F i = 0 Execute T(F i = 0) TBTB RIP B (F i = 0) No: Result in B Exists F k : RIP B (F k = 0) < 0? S = {F 1, F 2,..., F n } B = {F 1 = 1,..., F n = 1} B.F k = 0 S = S \ {F k } Yes: Find F k with minimal RIP B For each F i in S T B = T(F k = 0) COMPLEXITY: O(n 2 ) « [...] IE achieves better program performance than BE, since it considers the interaction of optimizations. However, when the interactions have only small effects, BE may perform close to IE in a faster way. »

CombinationF1F1 F2F2 RuntimeRIP B 1OFF 320 ms60% 2ONOFF160 ms-20% 3OFFON180 ms-10% 4ON 200 ms(0%) CombinationF1F1 F2F2 RuntimeRIP B 1OFF 320 ms100% 2ONOFF160 ms(0%) 3OFFON180 ms 4ON 200 ms TBTB TBTB 20

COMPLEXITY: O(n 2 ) « CE takes the advantages of both BE and IE. When the optimizations interact weakly, CE eliminates the optimizations with negative effects in one iteration, just like BE. Otherwise, CE eliminates them iteratively, like IE. » 1.Initialize S = {F 1, F 2,..., F n } and B = {F 1 = 1, F 2 = 1,..., F n = 1} 2.Determine the baseline T B : Compile the program with the options in B and measure its runtime. 3.For each optimization F i in S, compute RIP B (F i ) by compiling the program with the options in B, except F i which is turned off, and measuring its runtime. 4.Find the optimization F j with the most negative RIP b, remove it from S and set F j = 0 in B (The baseline changes!) 5.For all remaining F k with negative RIP b from step 4, recompute the RIP B (F k ) relative to the changed B. If still negative, remove F k from S and set it to 0 in B. 6.Repeat until all remaining optimizations have a positive RIP b. B now contains the "optimal" options. 21

22 F 1, F 2,..., F n Compile w/ B Execute Compile under B, but F i = 0 Execute T(F i = 0) TBTB RIP B (F i = 0) No: Result in B Exists F k : RIP B (F k = 0) < 0? S = {F 1, F 2,..., F n } B = {F 1 = 1,..., F n = 1} B.F k = 0 S = S \ {F k } Yes: Find F k with minimal RIP B For each F i in S T B = T(F k = 0) CE For all remaining F j with negative RIP B, check if the RIP B is still negative under the changed B. If so, remove F j directly. COMPLEXITY: O(n 2 ) « CE takes the advantages of both BE and IE. When the optimizations interact weakly, CE eliminates the optimizations with negative effects in one iteration, just like BE. Otherwise, CE eliminates them iteratively, like IE. »

1.Construct a set Ω which consists of a default optimization combination (Here: All on), and n combinations that each switch a single optimization off. 2.Measure the execution time under each combination in Ω. Keep only the m fastest combinations in Ω. 3.Construct a new Ω set consisting of all unions of two optimization combinations in the old Ω set. 4.Repeat 2 and 3 until no new combinations can be generated or the performance gain becomes insignificant. 5.The fastest version in the final Ω is the result. COMPLEXITY: O(nm 2 ) ~ O(n 3 ) 23 Idea from S. Triantafyllis, M. Vachharajani, N. Vachharajani, and D. I. August. Compiler optimization-space exploration. In Proceedings of the international symposium on Code generation and optimization, pages 204–215, 2003.

F1F1 F2F2...FnFn Combination Combination Combination Combination k0010 COMPLEXITY: O(n 2 ) You wouldn’t appreciate an in-depth explanation. 24 Shown in R. P. J. Pinkers, P. M. W. Knijnenburg, M. Haneda, and H. A. G. Wijshoff. Statistical selection of compiler options. In The IEEE Computer Societys 12th Annual International Symposium on Modeling, Analysis, and Simulation of Computer and Telecommunications Systems (MASCOTS’ 04), pages 494–501, Volendam, The Netherlands, October 2004.

Turtle: Rabbit: 25

26

Pentium 4 SPARC II CPU2000 Pentium IV: SPARC II: SPEC Logo: GCC Logo: 27 Ver

Reference Set Training Set Executable icon: All other illustrations except GCC logo are from Office.com. 28 #include

 Compression (2x)  Game Playing: Chess  Group Theory, Interpreter  C Programming Language Compiler  Combinatorial Optimization  Word Processing  PERL Programming Language  Place and Route Simulator  Object-oriented Database  FPGA Circuit Placement and Routing 29

30

31

32

CE: 2.96h OSE: 4.51h SS: 11.96h Effective average tuning time on 2.8 GHz (To scale) 33

#include for(i = 0; i < 10; ++i) { //... } if(!over) { //... } while(true) { printf("%d", ++j); if(j > 2 * i) break; } iOS-style on/off switch: 34