1. Optimizing Compilers CISC 673 Spring 2009 Course Overview
John Cavazos
University of Delaware

2. About Me John Cavazos <cavazos@cis> Assistant Professor, CIS
Research
Applying machine learning to hard systems problems
Compiling for advanced architectures
Interplay between compiler and architecture
Nitty-gritty things that happen in compiler back-ends
Rethinking fundamental structure of optimizing compilers

3. Overview Class format: Course website: Participatory & interactive
You take notes, read book & papers
Course website:

4. Overview Grades: Materials: 5% class participation
10% homework assignments
35% exams
50% project
Materials:
Selected papers
Compilers books on reserve in library

5. Project Stuff 1 to 2 person teams Implement optimization/analysis in:
JikesRVM (IBM’s research Java compiler)
Others subject to my approval
Due dates (roughly)
02/19/09: One-page project description.
03/05/09: 2-4 page project design.
04/07/09: Project implementation review.
05/05/09: Implementation due.
05/12-19/09: In-class presentations.
05/19/09: Project report.

6. Class Topics Some bread & butter analyses & optimizations
Control flow
Data flow analysis & implementation
Loop Transformations
SSA form
Register allocation
Instruction scheduling
Pointer analysis
Runtime systems (compiler must be aware of these!)

7. Class Topics Advanced topics (TBD) Autotuning
Optimizations for Parallel Programs
Program slicing
Error detection
Run time system interaction

8. Why Compilers Matter

9. What are Compilers, Anyway?
Compiler: translates program in one language to executable program in other language
Typically lowers abstraction level
E.g., Java/C++ to assembler
Optimizing compiler:
Misnomer!
Optimal compilation intractable
Improves program performance

10. Compilers Don’t Help Much
Do compilers improve performance anyway?
Proebsting’s law (Todd Proebsting, Microsoft Research):
Difference between optimizing and non-optimizing compiler ~ 4x
Assume compiler technology represents 36 years of progress (actually more)
Compilers double program performance every 18 years!
Not quite Moore’s Law…

11. Argumentum Ad Absurdum
Compilers don’t help much (Proebsting’s Law)
Don’t use optimizer
Hmmm…

12. A Big BUT
But: people will not accept massive performance hit for these gains
Compile with optimization!
Still use C and C++!!
Hand-optimize their code!!!
Even write assembler code (gasp)!!!!
Apparently performance does matter…
Multicores makes compilers even MORE important!

13. Why Compilers Matter
Key part of compiler’s job: make the costs of abstraction reasonable
Remove performance penalty for:
Using objects
Safety checks (e.g., array-bounds)
Writing clean code (e.g., recursion)
Use program analysis to transform code: primary topic of this course

14. Analysis & The Holy Grail
Other great uses for program analysis:
Static error-checking
Detect information leaks
Avoid security holes
Informing runtime system (e.g., GC)
Even better optimizations!
E.g., locality-improving transformations (“memory wall”)
Holy Grail for compiler research:
Programmer: writes simple but O(2^n) algorithm
Compiler: changes it to O(n log n) (or O(1)!)

15. Levels of Analysis (in order of increasing detail & complexity)
Local (single-block) [1960’s]
Straight-line code
Simple to analyze; limited impact
Intraprocedural [1970’s – today]
Whole procedure
Dataflow & dependence analysis
Interprocedural [late 1970’s – today]
Whole-program analysis
Tricky:
Very time and space intensive
Hard for some PL’s (e.g., Java)

16. Optimization = Analysis + Transformation
Key analyses:
Control-flow
if-statements, branches, loops, procedure calls
Data-flow
definitions and uses of variables
Representations:
Control-flow graph
Control-dependence graph
Def/use, use/def chains
SSA (Static Single Assignment)

17. About You