1. Computer Science 313 – Advanced Programming Topics

2. Loops Matter  Computers often used for repetitive analyses  Machines speed & memory advantageous for this  Not hurt by its lack of common sense  “Repetitive analyses” means loops  Loops occur everywhere in computer science  Performing statistical analyses on data  Database processing for result analyses  Evaluating results of large system simulation  Redrawing detailed pictures from WoW

3. Programs without Loops  What do we write that does NOT use loops?

4. Optimizing Loops Useful  Big differences from small change to loop  Size unimportant; time spent in execution important  Repeated execute the code in the loop  Even small changes become greatly magnified  Compiler limited in how it optimizes loops  Often lacks precise knowledge of how things work  Languages prevent optimizations across iterations  Non-inlined method calls cannot be optimize  Cannot optimize uses of an object or field

5. Simple Example  Consider following loop  Calls size() at start of each iteration  Calls get() within body of the loop int i; int retVal = 0; for (i = 0; i < list.size(); i++){ retVal += list.get(i); }

6. Minor Change  Make following changes which have little impact  Calls size() at start of loop, but not within iteration  Calls get() within body of the loop int i = list.size() - 1; int retVal = 0; for (; i >= 0; i--){ retVal += list.get(i); }

7. Another Small Change  Loop counts up, not down, in this version  Calls size() at start of loop, but not within iteration  Calls get() within body of the loop int end = list.size(); int retVal = 0; for (int i = 0; i < end; i++){ retVal += list.get(i); }

8. Little Odder Change  Limit iterations needed to complete loop  Calls size() at start of loop, but not within iteration  Calls get() within body of the loop int end = list.size(); int retVal, tmp1 = 0, tmp2 = 0; for (int i = 0; i < end; i+=2){ tmp1 += list.get(i); tmp2 += list.get(i + 1); } retVal = tmp1 + tmp2;

9. Execution Time of Each Loop

10. Reason for the 2 Big Drops  Biggest change when code moved out of loop loop hoisting loop invariant code-motion  Called loop hoisting or loop invariant code-motion  Loop hoisting done automatically by compiler  But only when it can determine optimization is safe  Need to understand how this works  Try to write code to enable optimization  Don’t write hard-to-read code duplicating optimization

11. Another Use of SSA Form  Method must be converted into SSA form  Find definition for each use of a variable  Instruction is loop-invariant when: t = x n  y n  x n & y n are both constant –or–  Definitions of x n & y n are outside the loop –or–  Loop-invariant instructions define x n & y n

12. Loop Hoisting Actions  Need location to place hoisted instructions  Where instructions moved when they get hoisted  Could try and remember where loop starts  Prepend instructions just before where loop start  Need to make sure is not included in loop  Much easier to add pre-loop header  Blank header included with all loops  Purpose is only to hold hoisted instructions

13. Loop-Invariant Example  Create loop header for loop  Any instruction should be mark as loop-invariant if:  Constant operands used  Operands def’d outside loop  Operands from other loop-invariant instructions x 1 = a 1 + 22 y 1 = b 1 + x 1 z 1 = foo() if (z 1 < 45) a 1 = … b 1 = …

14. Loop-Invariant Example  Create loop header for loop  Any instruction should be mark as loop-invariant if:  Constant operands used  Operands def’d outside loop  Operands from other loop-invariant instructions a 1 = … b 1 = … x 1 = a 1 + 22 y 1 = b 1 + x 1 z 1 = foo() if (z 1 < 45)

15. Loop-Invariant Example  Create loop header for loop  Any instruction should be mark as loop-invariant if:  Constant operands used  Operands def’d outside loop  Operands from other loop-invariant instructions a 1 = … b 1 = … y 1 = b 1 + x 1 z 1 = foo() x 1 = a 1 + 22 if (z 1 < 45)

16. Loop-Invariant Example a 1 = … b 1 = … z 1 = foo() x 1 = a 1 + 22 y 1 = b 1 + x 1 if (z 1 < 45)  Create loop header for loop  Any instruction should be mark as loop-invariant if:  Constant operands used  Operands def’d outside loop  Operands from other loop-invariant instructions

17. Loop-Invariant Example a 1 = … b 1 = … x 1 = a 1 + 22 y 1 = b 1 + x 1 if (z 1 < 45) z 1 = foo() c 1 = field

18. Must Also Meet Conditions  Must meet conditions  Pre-header dominates hoisted instruction  Loop contains exactly one variable definition do { i = i + 1 t = a * b M[i] = t } while (i < t); x = t

19. Must Also Meet Conditions  Must meet conditions  Pre-header dominates hoisted instruction  Loop contains exactly one variable definition do { if (i >= 45) t = a * b i = i + 1 M[i] = t } while (i < t); x = t

20. Must Also Meet Conditions  Must meet conditions  Pre-header dominates hoisted instruction  Loop contains exactly one variable definition do { if (i >= 45) t = a * b else t = a + b M[i] = t } while (i < t);

21. Great For Nested Loops  Fairly common to work with sets of loop  Databases & scientific data especially so  Can hoist instructions:  From outer loop to outside both loops  From inner loop to outside both loops  From inner loop to only in the outer loop  Normally nested loops use arrays or objects  Use scalar replacement to solve this

22. Nested Loop Example  Exposes reuse of a value  Array & object uses cannot be optimized  Use of local variable can be optimized  For really impressive sounding name:  Use dependence analysis to help rewrite loops

23. Loop Unrolling  Unroll to reduce overhead of the loop Advantages: + Fewer instructions executed + More optimizations possible + Great for consecutive accesses Disadvantages: - Code gets bloated - Still using objects

24. For Next Class  Lab available on the web  Lab will be due 1 week from Friday  Read pages 385 – 399 for this Friday  Begin looking at the State pattern  Closely related to what 2 patterns already discussed?  When and where would we want to use State pattern?